diff --git a/.fallout/build.schema.json b/.fallout/build.schema.json
index 47c6a4f95..b91c1e655 100644
--- a/.fallout/build.schema.json
+++ b/.fallout/build.schema.json
@@ -148,6 +148,16 @@
"type": "string",
"default": "Secrets must be entered via 'nuke :secrets [profile]'"
},
+ "NuGetSource": {
+ "type": "string"
+ },
+ "PublishTo": {
+ "type": "array",
+ "description": "Publish only to these named targets (default: all configured PublishTargets)",
+ "items": {
+ "type": "string"
+ }
+ },
"Solution": {
"type": "string",
"description": "Path to a solution file that is automatically loaded"
diff --git a/AssemblyInfo.cs b/AssemblyInfo.cs
index c5e26e6d6..106705c2b 100644
--- a/AssemblyInfo.cs
+++ b/AssemblyInfo.cs
@@ -1,22 +1,27 @@
using System.Runtime.CompilerServices;
-[assembly: InternalsVisibleTo("Fallout.Build")]
+[assembly: InternalsVisibleTo("Fallout.Application")]
[assembly: InternalsVisibleTo("Fallout.Build.Shared")]
-[assembly: InternalsVisibleTo("Fallout.Build.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Common")]
-[assembly: InternalsVisibleTo("Fallout.Common.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tools")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.CI")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tools.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.CI.Tests")]
[assembly: InternalsVisibleTo("Fallout.Cli")]
[assembly: InternalsVisibleTo("Fallout.Cli.Tests")]
-[assembly: InternalsVisibleTo("Fallout.ProjectModel.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.ProjectModel.Tests")]
[assembly: InternalsVisibleTo("Fallout.SourceGenerators")]
-[assembly: InternalsVisibleTo("Fallout.Solution")]
-[assembly: InternalsVisibleTo("Fallout.Solution.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Solutions")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Solutions")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Solutions.Tests")]
[assembly: InternalsVisibleTo("Fallout.Persistence.Solution")]
[assembly: InternalsVisibleTo("Fallout.Persistence.Solution.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Tooling")]
-[assembly: InternalsVisibleTo("Fallout.Tooling.Tests")]
-[assembly: InternalsVisibleTo("Fallout.Utilities.IO.Globbing")]
-[assembly: InternalsVisibleTo("Fallout.Utilities.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Tooling")]
+[assembly: InternalsVisibleTo("Fallout.Application.Tooling.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Infrastructure.Tooling.Tests")]
+[assembly: InternalsVisibleTo("Fallout.Kernel.IO.Globbing")]
+[assembly: InternalsVisibleTo("Fallout.Kernel.Tests")]
// External extensions — kept as Nuke.* until those projects rebrand independently.
[assembly: InternalsVisibleTo("Nuke.VisualStudio")]
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 49a482d1a..a5d80e327 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
### Breaking changes
+- **Onion layering — namespace realignment begun; `Fallout.Core` → `Fallout.Domain`** ([ADR-0006](docs/adr/0006-onion-layering-and-namespace-realignment.md)). First ring of a project-wide realignment to explicit onion layers (`Fallout.Domain` / `Fallout.Application` / `Fallout.Infrastructure`, `Fallout.Cli` composition root) with `namespace = project = layer`, dissolving the `Fallout.Common.*` catch-all. This entry covers **step 1 (the Domain ring)**; the Application/Infrastructure/tooling-port rings land on `experimental` as separate PRs (any that miss the 2026 cut roll to 2027).
+ - **Namespaces**: `Fallout.Core.Planning` → `Fallout.Domain.Planning`; `ITargetModel` and `ExecutionStatus` move out of `Fallout.Common.Execution` → `Fallout.Domain.Execution`. **Package/assembly**: `Fallout.Core` → `Fallout.Domain`. Replace the corresponding `using` directives and any `PackageReference`/`ProjectReference`.
+ - **Migration / shim**: the `Nuke.*` transition shims silently stop re-exporting the two moved types (the generator only mirrors the `Fallout.Common.*` prefix). A fresh migration/shim strategy is designed once the realignment completes (ADR-0006 defers it deliberately); native `Fallout.*` consumers rewrite the two `using`s above.
+ - **Step 2 (the Application ring)**: the core API `Fallout.Build` declared under `Fallout.Common.*` — `FalloutBuild`, `Target`, `[Parameter]` & attributes, `Host`, the execution engine, value injection, and the CI ports — moves to **`Fallout.Application.*`**. Native consumers rewrite `using Fallout.Common;` → `using Fallout.Application;` (and the `Fallout.Common.Execution`/`.CI`/`.ValueInjection` sub-namespaces likewise). Performed by a semantic rewriter (`tools/OnionRewriter`). The `Nuke.*` shim surface that mirrored these (`Nuke.Common.Target`, `…Parameter`, …) lapses for now — `Nuke.Consumer` and `Nuke.Common.Shim.Tests` are temporarily out of the solution until the migration phase. The `Fallout.Build` **assembly/project** is renamed to `Fallout.Application` in a later mechanical step (namespaces are already migrated).
+ - **Step 4a (Application ring — composition components)**: the build-composition interface family (`ICompile`, `IRestore`, `IPack`, `IPublish`, `ITest`, `IHas*`, `Configuration`, …), previously `Fallout.Components`, moves to **`Fallout.Application.Components`** — it composes the tool/CI vocabulary and so belongs in the Application ring. Native consumers rewrite `using Fallout.Components;` → `using Fallout.Application.Components;`. The `Nuke.Components` transition shim is unaffected for consumers: its public `Nuke.Components.*` face is unchanged (the shim generator's source prefix was repointed to the new namespace). The `Fallout.Components` **assembly/project** keeps its filename until the later mechanical rename step.
+ - **Step 4b (tool vocabulary → Application; executor → Infrastructure)**: the tool wrappers `Fallout.Common.Tools.*` (60+ wrappers) and the tool vocabulary they build on (`ToolTasks`, `ToolOptions`, `Output`, `Configure`, the `IProcess`/`IProcessRunner` ports, requirement/attribute types) move to **`Fallout.Application.Tools.*`** / **`Fallout.Application.Tooling`**. The impure executor that shared the `Fallout.Common.Tooling` namespace — `ProcessTasks`, `SystemProcessRunner`, `Process2`, `ProcessExtensions`, `ToolExecutor`, and the tool/package/version resolvers — moves to **`Fallout.Infrastructure.Tooling`**. Native consumers rewrite `using Fallout.Common.Tools.*;` → `using Fallout.Application.Tools.*;` and `using Fallout.Common.Tooling;` → `using Fallout.Application.Tooling;` (plus `using Fallout.Infrastructure.Tooling;` where they touch the executor directly). The `Nuke.Common.Tools`/`…Tooling` shim aliases lapse (the generator only mirrors the `Fallout.Common.*` prefix), pending the deferred migration/shim redesign. Assembly/project files (`Fallout.Common`, `Fallout.Tooling`) are unchanged; only namespaces moved.
+ - **Step 4b-follow-up (port inversion + Application-ring fitness gate)**: the impure tool-execution services now sit behind ports in `Fallout.Application.Tooling` — **`IProcessExecutor`**, **`IToolPathResolver`**, **`IToolVersionResolver`**, resolved via the new **`ToolingServices`** locator; Infrastructure registers thin adapters into it through a module initializer. The Application ring (tool wrappers, `ToolTasks`, `ToolResolver`, requirement/version attributes, build orchestration) no longer references `Fallout.Infrastructure.*`. `ProcessExtensions` (pure `IProcess`/`Output` helpers — `AssertWaitForExit`, `StdToJson`, …) was reclassified from Infrastructure back to `Fallout.Application.Tooling`. A NetArchTest fitness test (new `Fallout.Architecture.Tests`) asserts `Fallout.Application.*` ⊥ `Fallout.Infrastructure.*` and guards it. (Catch-all `Fallout.Common.*` code outside the Application ring — e.g. CI host adapters, single-file/path-check attributes — still reaches Infrastructure and is addressed when those namespaces get a ring in step 5.)
+ - **Step 5a (the `Fallout.Kernel` ring)**: the shared utility/IO layer — pure helpers (collections, string/text, reflection, `Assert`-adjacent guards, crypto, JSON/YAML), the `AbsolutePath`/`RelativePath` value types **and their fluent filesystem operations** (`.ReadAllText`/`.GlobFiles`/`.CreateDirectory`/…), plus HTTP/compression helpers — moves from `Fallout.Common.Utilities*` / `Fallout.Common.IO` to **`Fallout.Kernel`** / **`Fallout.Kernel.IO`** / **`Fallout.Kernel.Collections`** / **`Fallout.Kernel.Net`**, the innermost shared ring that the Domain/Application/Infrastructure rings build on. Native consumers rewrite `using Fallout.Common.Utilities;` → `using Fallout.Kernel;` (and `.Collections`/`.Net`) and `using Fallout.Common.IO;` → `using Fallout.Kernel.IO;`. **Filesystem is treated as a kernel-level capability** (like the BCL `File`/`Directory`): the fluent `AbsolutePath` API is used pervasively across the Application ring, so routing it through ports would be impractical and anti-ergonomic — it stays in Kernel rather than moving to Infrastructure. Pushing the genuinely-external adapters (HTTP/FTP, compression) further out to Infrastructure is deferred for the same reason (they need the same ports decision). The `Fallout.Utilities` assembly/project keeps its filename until the later mechanical rename to `Fallout.Kernel`; a few root-`Fallout.Common` guards (`Assert`, `NotNull`, `EnvironmentInfo`) remain in the dissolving catch-all for now and fold into Kernel later.
+ - **Step 5b (CI host providers → Infrastructure)**: the concrete CI provider classes (`AppVeyor`, `AzurePipelines`, `TeamCity`, `GitHubActions`, `GitLab`, `TravisCI`, …) and their config generators move from `Fallout.Common.CI.*` to **`Fallout.Infrastructure.CI.*`**. The Application ring reaches the provider-specific capabilities it needs (publish test results/coverage, push artifacts, set/update the build number, read the token, …) through new **ports in `Fallout.Application.CI`** — `IAppVeyor`/`IAzurePipelines`/`ITeamCity`/`IGitHubActions` plus a **`CiHost`** accessor that casts the detected `Host.Instance` to the port (no registration needed — `Host.Instance` is the existing detection seam). Components and version/coverage attributes rewrite `AzurePipelines.Instance?.X` → `CiHost.AzurePipelines?.X`, so the Application ring stays free of `Fallout.Infrastructure.*` (the fitness gate still passes). The two enums the ports expose (`AzurePipelinesTestResultsType`, `AzurePipelinesCodeCoverageToolType`) move to `Fallout.Application.CI` as vocabulary. The `Nuke.Common.CI.*` transition-shim host accessors are repointed to the new Infrastructure namespace. (The generic CI host abstraction — ADR-0005 `IBuildHost`/`IBuildReporter`, [#341] — remains a separate, additive effort.)
+ - **Step 5c (ProjectModel/Solution → rings)**: the solution model + `[Solution]` injection + `ReadSolution` move to **`Fallout.Application.Solutions`** (a Fallout-owned POCO model with an opaque handle, behind `ISolutionSerializer`/`IProjectEditor` ports + a `SolutionServices` locator); the `.sln`/`.slnx` serializer adapter → **`Fallout.Infrastructure.Solutions`**; the MSBuild project evaluator (`ProjectModelTasks`/`ProjectExtensions`) → **`Fallout.Infrastructure.ProjectModel`**. Also finished the partial straggler moves (Git/ChangeLog → `Fallout.Application.*`; `Assert`/`EnvironmentInfo`/`AsyncHelper`/`ArgumentParser` → `Fallout.Kernel`; Execution + Gitter → Application).
+ - **Project-file renames + splits + meta-package (the mechanical step the entries above forward-referenced)**: with namespaces settled, the **project files, assemblies, and NuGet package IDs** now match the rings. Pure renames: `Fallout.Build` → **`Fallout.Application`**, `Fallout.Components` → **`Fallout.Application.Components`**, `Fallout.ProjectModel` → **`Fallout.Infrastructure.ProjectModel`**, `Fallout.Utilities*` → **`Fallout.Kernel*`**. Mixed projects split into ring-pure assemblies: `Fallout.Tooling` → **`Fallout.Application.Tooling`** + **`Fallout.Infrastructure.Tooling`**; `Fallout.Solution` → **`Fallout.Application.Solutions`** + **`Fallout.Infrastructure.Solutions`**; the 249-file **`Fallout.Common` catch-all is dissolved** → `Fallout.Application.Tools` (tool wrappers), `Fallout.Infrastructure.CI` (CI adapters), `Fallout.Application`, and `Fallout.Kernel`. **Consumers now reference a new thin `Fallout` meta-package** (successor to `Fallout.Common` — references every ring + carries the MSBuild integration `Fallout.props`/`.targets`, the MSBuildTasks output, and the source-generator analyzer); `dotnet fallout :setup`/`:update` target `Fallout`. **Package-ID migration**: replace `Fallout.Common` → `Fallout`; `Fallout.Build`/`.Components`/`.ProjectModel`/`.Tooling`/`.Solution`/`.Utilities*` → their ring names above. **TFMs**: dropped `net472` from `Fallout.MSBuildTasks` (Fallout is `dotnet build`-only); `Fallout.Domain` → `net10.0`; netstandard2.0 retained only on the Roslyn generators and the ring halves they consume (`Fallout.Application.Tooling`/`.Solutions`, `Fallout.Kernel*`, `Fallout.Build.Shared`); `Fallout.Infrastructure.ProjectModel` keeps `net8.0;net9.0;net10.0` (per-TFM Microsoft.Build SDK matching). The fitness gate now operates on ring-pure assemblies. The build's own `[ModuleInitializer]` force-loader now runs each `Fallout.*` assembly's module constructor (`RuntimeHelpers.RunModuleConstructor`), so the split-out Infrastructure adapters register deterministically.
+ - **Shim + migration redesign (the deferred `Nuke.*` strategy, now landed)**: a single canonical `Nuke ↔ Fallout` namespace map (`src/Shared/NukeNamespaceMap.cs`) drives both the transition shims (Fallout→Nuke re-exports) and the `fallout-migrate` rewriters (Nuke→Fallout), which the realignment had desynchronised (the migration was emitting dead `Fallout.Common.*` namespaces). **Shim packages collapse from 3 to 2**: `Nuke.Common` (now references the `Fallout` meta-package and re-exports every `Nuke.Common.*` sub-namespace — Tooling/Tools/CI/ProjectModel/Git/IO/Execution/ValueInjection/ChangeLog/Utilities — wherever the source type now lives across the rings) and `Nuke.Components`. **`Nuke.Build` is removed** (it was never a real NUKE consumer package — `NukeBuild` lives in `Nuke.Common`); consumers who referenced it migrate to `Fallout`. **The migration's package rewrite** maps the `Nuke.Common` package → the `Fallout` meta and `Nuke.Components` → `Fallout.Application.Components` (not a dead `Fallout.Common`/`Fallout.Components`). **`dotnet fallout` Cake migration support (`:cakeconvert`/`:cakeclean`) is dropped** entirely.
- **Adopted calendar versioning (`YYYY.MINOR.PATCH`) + dual-pace channel model; retired the v11 numbering** ([ADR-0004](docs/adr/0004-calendar-versioning-and-dual-pace-channels.md)). Fallout now ships on calendar versions (`2026.0.0`, `2026.1.0`, …) — mechanically valid SemVer with the major equal to the calendar year. **Breaking changes are batched to the yearly major cut**; mid-year stable releases (`release/YYYY`) are strictly non-breaking. `main` becomes the published **edge** channel (date-stamped prereleases to GitHub Packages); the slow/stable track lives on `release/YYYY`. Opt-in unstable APIs are marked `[Experimental("FALLOUT0xx")]`.
- **Migration / impact**: the `11.0.x` packages never shipped a clean stable release (all unlisted), so this strands no stable consumers. The headline content previously slated for "v11" now ships as **`2026.0.0`**. Any tooling pinned to a `[11.0,12.0)`-style range should retarget the `2026.x` line.
- **Legacy unaffected**: the `release/v10` line stays on semver `10.x` and continues to receive security/critical fixes — v10 consumers do nothing.
diff --git a/build/Build.CI.GitHubActions.cs b/build/Build.CI.GitHubActions.cs
index 6a272c419..b6160ba19 100644
--- a/build/Build.CI.GitHubActions.cs
+++ b/build/Build.CI.GitHubActions.cs
@@ -1,5 +1,5 @@
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Components;
+using Fallout.Application.Components;
+using Fallout.Infrastructure.CI.GitHubActions;
// Cross-platform (macOS/Windows) full Test+Pack is gated to RELEASE INTENT
// (#318/#326): it runs only on a PR into a production branch (release/YYYY,
diff --git a/build/Build.CodeGeneration.cs b/build/Build.CodeGeneration.cs
index f8ab28165..99b5e9126 100644
--- a/build/Build.CodeGeneration.cs
+++ b/build/Build.CodeGeneration.cs
@@ -1,11 +1,12 @@
-using System;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities.Collections;
+using System;
using static Fallout.CodeGeneration.CodeGenerator;
using static Fallout.CodeGeneration.ReferenceUpdater;
-using static Fallout.Common.Tools.Git.GitTasks;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.Git;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
partial class Build
{
diff --git a/build/Build.Contributors.cs b/build/Build.Contributors.cs
index a3910c293..aad2ae16b 100644
--- a/build/Build.Contributors.cs
+++ b/build/Build.Contributors.cs
@@ -1,10 +1,11 @@
using System.Linq;
using System.Text;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.Git.GitTasks;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.Git;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
partial class Build
{
diff --git a/build/Build.GlobalSolution.cs b/build/Build.GlobalSolution.cs
index 7efdea75f..d59836861 100644
--- a/build/Build.GlobalSolution.cs
+++ b/build/Build.GlobalSolution.cs
@@ -2,15 +2,16 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Git;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
-using Fallout.Utilities.Text.Yaml;
-using static Fallout.Common.ControlFlow;
-using static Fallout.Common.Tools.Git.GitTasks;
+using Fallout.Kernel;
+using static Fallout.Application.ControlFlow;
+using static Fallout.Application.Tools.Git.GitTasks;
+using Fallout.Application;
+using Fallout.Application.Git;
+using Fallout.Application.Tools.Git;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Text.Yaml;
+using Fallout.Application.Solutions;
partial class Build
{
@@ -20,7 +21,7 @@ partial class Build
AbsolutePath ExternalRepositoriesDirectory => RootDirectory / "external";
AbsolutePath ExternalRepositoriesFile => ExternalRepositoriesDirectory / "repositories.yml";
- IEnumerable ExternalSolutions
+ IEnumerable ExternalSolutions
=> ExternalRepositories
.Select(x => ExternalRepositoriesDirectory / x.GetGitHubName())
.Select(x => x.GlobFiles("*.sln").Single())
diff --git a/build/Build.Licenses.cs b/build/Build.Licenses.cs
index 833e45b38..9c6ca2b7f 100644
--- a/build/Build.Licenses.cs
+++ b/build/Build.Licenses.cs
@@ -1,11 +1,12 @@
-using Fallout.Common;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
-using Fallout.Common.IO;
-using Fallout.Components;
using Serilog;
-using static Fallout.Common.IO.HttpTasks;
+using static Fallout.Application.IO.HttpTasks;
+using Fallout.Application;
+using Fallout.Application.Components;
+using Fallout.Kernel.IO;
+using Fallout.Application.IO;
partial class Build
{
diff --git a/build/Build.PublicApi.cs b/build/Build.PublicApi.cs
index c14305a40..6504ae02b 100644
--- a/build/Build.PublicApi.cs
+++ b/build/Build.PublicApi.cs
@@ -2,10 +2,10 @@
using System.Linq;
using System.Reflection;
using System.Text;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
+using Fallout.Application;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
partial class Build
{
diff --git a/build/Build.RunTargetInDockerTest.cs b/build/Build.RunTargetInDockerTest.cs
index 2fc40032e..e99232e05 100644
--- a/build/Build.RunTargetInDockerTest.cs
+++ b/build/Build.RunTargetInDockerTest.cs
@@ -1,8 +1,8 @@
using System;
-using Fallout.Common;
-using Fallout.Common.Tools.Docker;
-using Fallout.Common.Utilities;
using Serilog;
+using Fallout.Application;
+using Fallout.Application.Tools.Docker;
+using Fallout.Kernel;
partial class Build
{
diff --git a/build/Build.Stargazers.cs b/build/Build.Stargazers.cs
index 72d5449ba..bad3eee7c 100644
--- a/build/Build.Stargazers.cs
+++ b/build/Build.Stargazers.cs
@@ -1,9 +1,9 @@
-using System.Linq;
+using System.Linq;
using System.Threading.Tasks;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
+using Fallout.Application;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
partial class Build
{
diff --git a/build/Build.Terminal.cs b/build/Build.Terminal.cs
index 0a6f8e90c..589a7cf17 100644
--- a/build/Build.Terminal.cs
+++ b/build/Build.Terminal.cs
@@ -1,7 +1,7 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Execution;
+using Fallout.Application.Execution;
+using Fallout.Application;
[DisableDefaultOutput(
DefaultOutput.Logo,
diff --git a/build/Build.cs b/build/Build.cs
index b1ecb3288..7d26211c4 100644
--- a/build/Build.cs
+++ b/build/Build.cs
@@ -2,20 +2,22 @@
using System.Collections.Generic;
using System.Linq;
using NuGet.Packaging;
-using Fallout.Common;
-using Fallout.Common.CI;
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Common.Execution;
-using Fallout.Common.Git;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
-using Fallout.Components;
-using static Fallout.Common.ControlFlow;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.ControlFlow;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.CI;
+using Fallout.Application.Git;
+using Fallout.Application.Execution;
+using Fallout.Application.Components;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
+using Fallout.Infrastructure.Tooling;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
+using Fallout.Infrastructure.CI.GitHubActions;
+using Fallout.Application.Solutions;
+using Fallout.Infrastructure.ProjectModel;
[DotNetVerbosityMapping]
[ShutdownDotNetAfterServerBuild]
@@ -39,7 +41,7 @@ partial class Build
GitRepository GitRepository => From().GitRepository;
[Solution(GenerateProjects = true)] readonly Solution Solution;
- Fallout.Solutions.Solution IHasSolution.Solution => Solution;
+ Fallout.Application.Solutions.Solution IHasSolution.Solution => Solution;
AbsolutePath OutputDirectory => RootDirectory / "output";
AbsolutePath SourceDirectory => RootDirectory / "source";
@@ -96,12 +98,12 @@ private static int ParseMajor(string informationalVersion)
.When(!ScheduledTargets.Contains(((IPublish)this).Publish) && !ScheduledTargets.Contains(Install), _ => _
.ClearProperties());
- IEnumerable<(Fallout.Solutions.Project Project, string Framework)> ICompile.PublishConfigurations =>
+ IEnumerable<(Fallout.Application.Solutions.Project Project, string Framework)> ICompile.PublishConfigurations =>
from project in new[] { Solution.Fallout_Cli, Solution.Fallout_MSBuildTasks }
from framework in project.GetTargetFrameworks()
select (project, framework);
- IEnumerable ITest.TestProjects => Partition.GetCurrent(Solution.GetAllProjects("*.Tests"));
+ IEnumerable ITest.TestProjects => Partition.GetCurrent(Solution.GetAllProjects("*.Tests"));
[Parameter]
public int TestDegreeOfParallelism { get; } = 1;
diff --git a/build/_build.csproj b/build/_build.csproj
index cee68e3d4..f58cff136 100644
--- a/build/_build.csproj
+++ b/build/_build.csproj
@@ -1,6 +1,6 @@
-
+
Exe
@@ -66,11 +66,26 @@
-
+
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/adr/0006-onion-layering-and-namespace-realignment.md b/docs/adr/0006-onion-layering-and-namespace-realignment.md
new file mode 100644
index 000000000..a5a1c4154
--- /dev/null
+++ b/docs/adr/0006-onion-layering-and-namespace-realignment.md
@@ -0,0 +1,113 @@
+# ADR-0006 — Onion layering + namespace realignment
+
+- **Status:** Proposed
+- **Date:** 2026-05-31
+- **Deciders:** Fallout maintainers
+- **Relates to:** ADR-[0004](0004-calendar-versioning-and-dual-pace-channels.md) (calendar versioning + channels — sets the breaking-change home), ADR-[0005](0005-ci-host-integration-ports-and-adapters.md) (the runtime-host ports the Application layer exposes), [docs/rebrand-plan.md](../rebrand-plan.md) (**amends** its deferral — see below)
+- **Spike:** [docs/spikes/0002-onion-domain-ring.md](../spikes/0002-onion-domain-ring.md)
+
+## Context
+
+The project + namespace structure is inherited verbatim from NUKE: the rebrand ([#32](https://github.com/ChrisonSimtian/Fallout/issues/32)) did a **strict 1:1 prefix swap** (`Nuke.X` → `Fallout.X`) that deliberately preserved the existing shape. Two pathologies result:
+
+1. **Namespace ≠ project.** Most projects declare types under `Fallout.Common.*` rather than their own name. The core user-facing API (`FalloutBuild`, `Target`, `[Parameter]`, and the ADR-0005 ports) lives in namespace `Fallout.Common` inside project `Fallout.Build`. `Fallout.Core` declares both `Fallout.Core.Planning` and `Fallout.Common.Execution`. Every `Fallout.Utilities.*` sub-project (except `.Text.Yaml`) declares `Fallout.Common.*`. `Fallout.Tooling` → `Fallout.Common.Tooling`. `Fallout.Solution` (singular) → `Fallout.Solutions` (plural). `Fallout.Tooling.Generator` → `Fallout.CodeGeneration`.
+
+2. **`Fallout.Common.*` is a horizontal catch-all** contributed by **five** projects (`Build`, `Common`, `Core`, `Utilities`, `SourceGenerators`). It masks a layering that already exists *physically* — the `ProjectReference` graph is clean and acyclic (`Core`/`Utilities` at the bottom → `Build` → `Common` → `Cli` at the root) — but the namespaces lie about it.
+
+### Why now, and why this amends the rebrand plan
+
+`docs/rebrand-plan.md` explicitly **defers** "realigning project ↔ namespace" to "a future major version after the shim packages have sunset," citing the type-forwarding bridge as the blocker. This ADR **amends that deferral** on two grounds:
+
+- **The bridge is not a blocker.** The rebrand-plan deferred this work *because* it assumed a rigid `[TypeForwardedTo]` bridge. The actual machinery is the `TransitionShimGenerator` (`ShimAllPublicTypesUnder(from, to)`), a *prefix-remappable* subclass generator — so restructuring `Fallout.*` doesn't orphan the `Nuke.*` surface in principle. We nonetheless **defer the migration strategy wholesale** (see Decision §"Migration & shim strategy") rather than re-point ring-by-ring; the point here is only that the stated blocker doesn't bind.
+- **ADR-0004 gives a clean home.** Namespace realignment is breaking → it lands on `experimental` and is **batched to the next yearly major cut**. The `2026` major has **not cut yet** (no calendar-version GA tag exists; CHANGELOG `[Unreleased] — 2026.0` is still accumulating breaking changes), so this work can ride the **2026** cut and ship this year. Rings that aren't done before `2026.0.0` cuts roll to `2027`. Either way native `Fallout.*` consumers are carried by the deferred migration phase; old `Fallout.*` namespaces are deleted at the cut, not dragged.
+
+(The rebrand-plan is a transient maintainer-owned doc; this is a deliberate, recorded reversal of one of its deferrals, not a silent contradiction.)
+
+## Decision
+
+**Realign the runtime codebase to explicit onion layers, with `namespace = project = layer`.**
+
+| Layer | Holds | Today (selected) → target |
+|---|---|---|
+| **`Fallout.Domain.*`** (innermost; zero Fallout deps) | Target graph, planning algorithms, execution status, the read-only build model | `Fallout.Core` (`Fallout.Core.Planning` + `Fallout.Common.Execution`'s `ITargetModel`/`ExecutionStatus`) → `Fallout.Domain` |
+| **`Fallout.Application.*`** (orchestration + ports + vocabulary; depends only on Domain) | `FalloutBuild`, `Target`, `[Parameter]` & attributes, execution engine (`BuildManager`/`Executor`/`Planner`), middleware pipeline, value injection, `Host` base; the ports (`IBuildHost`, `IBuildReporter`, `IConfigurationGenerator`, `IBuildServer`, **and a process/tool-execution port**); the **typed tool vocabulary** (`Options`/`ToolOptions` model + the generated wrappers like `DotNetTasks` & settings — pure command builders); and the **`Fallout.Components` recipes** | `Fallout.Build` + the `Fallout.Common*` it declares; `Fallout.Common.Tools.*` (wrappers) + the pure part of `Fallout.Tooling`; `Fallout.Components` → `Fallout.Application.*` |
+| **`Fallout.Infrastructure.*`** (I/O adapters behind the ports; depends on Application/Domain) | The adapters that actually touch the outside world: the **process/tool runner** (OS process spawn), filesystem, HTTP, tool-path/package resolvers, **CI host adapters**, config-file writers, project/solution readers | `Fallout.Common.CI.*` → `.Infrastructure.CI.*`; the executor part of `Fallout.Tooling` (`ProcessTasks`/`ToolExecutor`) + `Fallout.Utilities.IO`/`.Net`/`.Compression`/`.Globbing` → `.Infrastructure.*`; `Fallout.ProjectModel`/`Fallout.Solution(s)` → `.Infrastructure.ProjectModel`/`.Solutions` |
+
+**The tool layer splits along purity** (decided after reviewing `DotNetBuild`'s shape — see ADR-0005's ports pattern applied to the deepest I/O): the **command vocabulary** (`DotNetBuildSettings : ToolOptions` is pure data; `DotNetBuild` just constructs argv) is Application; the **one impure step** — `ProcessTasks.StartProcess` spawning a real OS process (today a *static* call) — becomes an injectable **process/tool-execution port** with the OS adapter in Infrastructure. This is what lets `Fallout.Components` (e.g. `ICompile` calling `DotNetBuild`) live in Application without the inner ring depending on a concrete — and it makes builds unit-testable by faking the runner. There is deliberately **no** generic "abstract build" port: `ICompile` is irreducibly DotNet-specific, so abstracting it would be anemic or a re-spelling of DotNet — the wrong abstraction. The seam is *execution*, not *build semantics*.
+| **`Fallout.Cli`** (composition root) | Entry points, host integration | `Fallout.Cli`, `Fallout.MSBuildTasks`, `Fallout.Migrate` — unchanged |
+
+**Outside the runtime onion** (build-time tooling, kept as-is): `Fallout.SourceGenerators`, `Fallout.Tooling.Generator` (the `Fallout.CodeGeneration` codegen), `Fallout.Migrate.Analyzers`. The vendored `Fallout.Persistence.Solution` keeps its namespace (Microsoft code).
+
+**Rules:**
+1. **`namespace == project == layer`.** No project declares a namespace rooted outside its layer. `Fallout.Common` is **dissolved**.
+2. **Onion dependency rule, fitness-enforced.** Domain references no other Fallout assembly; Application references only Domain; Infrastructure references Application/Domain; only the Cli composition root references Infrastructure. One architecture-test per ring, added as each ring lands (extends the ADR-0005 boundary-test pattern).
+3. **Breaking → `experimental` → the next yearly major** (ADR-0004). The `2026` major is still unreleased, so rings ride the **2026** cut (`target/2026`) until it closes; anything after rolls to `2027`. A breaking PR targets `experimental` only and carries `target/` + `breaking-change` + a `CHANGELOG.md` entry under that major.
+4. **Ring-by-ring migration**, inner to outer — each ring is its own PR on `experimental`. The spike (0002) proves the mechanics on the Domain ring before the larger rings.
+5. **Migration/shim strategy is deferred wholesale** — see below.
+
+### Migration & shim strategy: deferred by design
+
+The `Nuke.*` transition shims (and any native-`Fallout.*` migration aid) are **explicitly out of scope for the rearchitecture rings.** Rationale: there's no point re-pointing the existing `TransitionShimGenerator` ring-by-ring toward a target that's still moving. Instead — once the final layered shape has settled — we design a **fresh migration/shim strategy that fits whatever we ended up with**, as its own phase and its own ADR. The existing bridge is re-pointable (it's a prefix-remappable subclass generator, not raw `[TypeForwardedTo]`), so this deferral costs us no future optionality; it's a sequencing choice, not a capability loss.
+
+Consequence during the work: on `experimental`, `Nuke.*` shim parity is **not maintained** while the rings land. That's acceptable — `experimental` is the unstable lane, and the only deadline that matters is the major cut the rings target; the new migration story is built before that cut. `Fallout.Migrate` likewise gets revisited then, not incrementally.
+
+### Sequence (each step a PR on `experimental`, with its own ring fitness test)
+
+1. **Domain ring** — extract `Fallout.Domain` (spike [0002](../spikes/0002-onion-domain-ring.md)). Innermost, smallest; proves the move → reference-fixup → fitness loop.
+2. **Application ring** — rename `Fallout.Build` → `Fallout.Application` and dissolve the `Fallout.Common` core API into it (the user-facing `FalloutBuild`/`Target`/`[Parameter]` rename — the big one).
+3. **Tooling/execution-port spike** — extract the process/tool-execution port; split `Fallout.Tooling` into pure vocabulary (Application) + executor adapter (Infrastructure). Unlocks tool wrappers as Application vocabulary and is a standalone testability win. *(Can run in parallel with step 2; must precede step 4.)*
+4. **Tool vocabulary + `Components` → Application** — move the wrappers and the `Fallout.Components` recipes in, now that execution is behind the port.
+5. **Infrastructure ring** — CI host adapters, IO/Net/compression/globbing, path/package resolvers, project/solution readers → `Fallout.Infrastructure.*`.
+
+Migration/shim strategy is redesigned after step 5, before the cut (deferred, above).
+
+## Judgment calls (flagged for review — defaults chosen, easily changed)
+
+- **Public API under `.Infrastructure`.** Tool wrappers and CI attributes are consumer-facing yet land under `Fallout.Infrastructure.*` (the hexagonal reading: adapters are infrastructure even when public). Consequence: consumer `using` directives grow (`using Fallout.Infrastructure.Tools.DotNet;`). **Mitigation:** ship a curated set of global usings in the `dotnet fallout` project template so day-to-day build authoring isn't verbose. *Accepted by maintainer; recorded so the ergonomics cost is visible.*
+- **`Fallout.Components` → Application (RESOLVED, not an open default).** The mixins call tool wrappers (`ICompile.Compile` → `DotNetBuild`). Rather than exile `Components` to an outer ring, we **invert the dependency**: the tool wrappers become Application *vocabulary* and the one impure step (process spawn) moves behind the process/tool-execution port (see the layer table). `Components` then depends only on Application vocabulary + that port and lives in `Application` cleanly. **Prerequisite:** the tooling/execution-port spike (step 3 of the Sequence) lands before the wrappers + `Components` move.
+- **Utilities as Infrastructure vs shared kernel.** IO/Net/compression are genuinely infrastructure. Pure-algorithmic helpers (collections, reflection, string) are more a shared kernel; default is to keep a minimal shared-kernel that Domain may depend on, rather than forcing it through Infrastructure (which would violate the inner ring). To be pinned during the Application/Infrastructure rings.
+
+## Consequences
+
+### Positive
+- The namespace finally tells the truth about the layer, and the onion dependency rule is enforced by construction (fitness tests), not convention.
+- `Fallout.Common` — the catch-all — is gone; no more "five projects, one namespace."
+- Sets the stage cleanly for the public plugin SDK (milestone #7): adapters live in a named Infrastructure layer behind the Application-owned ports.
+
+### Negative
+- **Large, breaking, multi-PR.** Touches nearly every file's `namespace`/`using`. Mitigated by ring-by-ring sequencing, re-pointed shims, the migrate codefix, and batching to one yearly major.
+- **Consumer churn** for native `Fallout.*` users, and a window on `experimental` where `Nuke.*` shim parity lapses. Both are carried by the deferred migration phase (a fresh strategy + CHANGELOG migration guide), built before the target major cut — not during the rings.
+
+## Alternatives considered
+
+- **Concern-aligned names** (`Fallout.Core`/`Build`/`Tooling`/`Tools`/`CI`/`IO`), namespace=project but not layer-labelled. Lower consumer surprise (keeps short names), fits the repo's by-concern convention. **Not chosen** — maintainer wants explicit onion layer names so the architecture is legible from the namespace alone.
+- **Keep `Fallout.Common` as a thin facade** re-exporting the layered types. Less churn. **Not chosen** — keeps a name we want gone ("don't drag dead weight").
+- **Minimal — fix only the internal mismatches.** Smallest break. **Not chosen** — leaves the catch-all and doesn't achieve the onion goal.
+- **Defer to "after shim sunset" (status quo per rebrand-plan).** **Not chosen** — see "Why now"; the work is wanted this year.
+
+## Amendments
+
+- **2026-06-01 — `Fallout.Kernel` + filesystem/external-IO is kernel-level (resolves the "Utilities as Infrastructure vs shared kernel" judgment call above, and amends the layer table's IO/Net/compression/globbing → Infrastructure entry).** During the Infrastructure ring (spike 0003 steps 5a/5d), the open default in *Judgment calls* — "IO/Net/compression are genuinely infrastructure" — was **reversed for the fluent vocabulary**. A new innermost shared ring **`Fallout.Kernel`** (Domain/Application/Infrastructure all depend on it; Domain stays zero-dep otherwise) holds the pure helpers **and** the fluent IO vocabulary:
+ - **Filesystem is a kernel-level capability** (like the BCL's `File`/`Directory`): `AbsolutePath` + all its fluent ops (`.ReadAllText`/`.GlobFiles`/`.CreateDirectory`/`.ZipTo`/…) stay in Kernel. Rationale: the fluent API is used pervasively across the Application ring; routing it through an `IFileSystem` port would be hundreds of call sites that kill the ergonomics, and placing it in Infrastructure would fail the Application-ring fitness gate.
+ - **The same reasoning extends to the rest of external-IO *vocabulary* (5d):** the fluent HTTP client (`HttpClient.CreateRequest(...).Send()` extensions over the BCL `HttpClient`), compression (`.ZipTo()`/`.UnZipTo()` — themselves `AbsolutePath` extensions), and glob all stay in Kernel. Every one is consumed by *gated* Application-ring code (tool wrappers, `Components`, version-resolver attributes), so a clean move would break the gate, and they are thin ergonomic layers over BCL capabilities — not genuine external adapters worth a port. `HttpTasks`/`FtpTasks` (download-URL-to-file) are the one coarse "network task" category; kept in Kernel for now, with an optional `IHttpDownload`-style port → Infrastructure left as deferred future work (not required for the gate).
+ - **What still goes to Infrastructure** is unchanged: process/tool execution (4b), CI host adapters (5b), tool-path/package resolvers (4b), and project/solution readers (5c, via ports). The seam is *genuine external side-effecting adapters behind Application-owned ports*, not "anything in a namespace called IO/Net."
+
+- **2026-06-01 — project-file renames + splits + the `Fallout` meta-package (the realignment's final mechanical step).** With every namespace settled, the project files / assemblies / NuGet package IDs were brought to `ring = project = namespace = assembly = package`. Ring-pure projects were renamed (`Fallout.Build`→`.Application`, `Fallout.Components`→`.Application.Components`, `Fallout.ProjectModel`→`.Infrastructure.ProjectModel`, `Fallout.Utilities*`→`Fallout.Kernel*`); the three mixed projects were split into ring-pure assemblies (`Fallout.Tooling`→`Application.Tooling`+`Infrastructure.Tooling`; `Fallout.Solution`→`Application.Solutions`+`Infrastructure.Solutions`; the `Fallout.Common` catch-all dissolved into `Application.Tools`+`Infrastructure.CI`+`Application`+`Kernel`).
+ - **Consumer anchor = a new thin `Fallout` meta-package** (resolves the open question of what replaces `Fallout.Common` as the "reference-one-package" entry point). It holds no code: it references every ring and carries the MSBuild integration (`Fallout.props`/`.targets`), the MSBuildTasks publish output, and the source-generator analyzer. `dotnet fallout :setup`/`:update` target it.
+ - **Splitting ports from adapters required a module-init fix.** Co-hosting ports + their `[ModuleInitializer]` adapter registrations in one assembly had masked a latent bug: `Assembly.Load` loads metadata but does **not** run a `[ModuleInitializer]` (it fires lazily on first *use* of a type in the assembly). Once adapters moved to assemblies nothing references by type, their registration never ran (null `ToolingServices`/`SolutionServices` → swallowed NRE at build runtime, invisible to unit tests). Fix: the build's force-loader (`BuildManager.Initialize`) now calls `RuntimeHelpers.RunModuleConstructor` on each `Fallout.*` assembly; the source generator reads solutions via a direct `SolutionReader` call (a Roslyn host can't use the locator); test hosts force-run the adapter module ctors. This is the general pattern for any future ring split.
+ - **Placement is dependency-driven, not namespace-driven.** Injection/extension attributes (`[Solution]`, `[Latest*]`, `[GitRepository]`, globbing attrs) and a few `ControlFlow`/`Configure`-coupled IO helpers (FtpTasks/HttpTasks) live in the `Fallout.Application` assembly despite their `Application.Solutions`/`Application.Tooling`/`Kernel.IO` namespaces — their base classes live there and the leaf ring projects are referenced *by* Application, so homing them in the leaves would cycle. Accepted residual: a handful of `Kernel.IO`-namespace files sit in the Application assembly (ring-safe — no Infra dependency; the gate stays green); a namespace-vs-assembly tidy-up is left for later.
+ - **TFMs:** `net472` dropped (Fallout is `dotnet build`-only); `Fallout.Domain`→`net10.0`; `netstandard2.0` retained only on the Roslyn generators and the ring halves they consume; `Fallout.Infrastructure.ProjectModel` keeps `net8.0;net9.0;net10.0` (per-TFM Microsoft.Build pinning matches the evaluator to the SDK — load-bearing, not incidental).
+
+- **2026-06-01 — `Nuke.*` shim + Migrate redesign (the deferred migration strategy, now resolved).** The realignment deliberately deferred the shim/migration rework "until the rings land" (above). Now landed: **one canonical `Nuke ↔ Fallout` namespace map** (`src/Shared/NukeNamespaceMap.cs`, linked into the generator + both migration projects) is the single source of truth for both directions — the transition-shim generator (Fallout→Nuke re-exports) and the `fallout-migrate` rewriters (Nuke→Fallout). This fixes the desync the onion caused (the migration's blind `Nuke.`→`Fallout.` swap had been producing dead `Fallout.Common.*` output).
+ - **The 1:1 shim-package↔Fallout-project mapping is abandoned** (it assumed `Nuke.Common`↔`Fallout.Common`, which dissolving `Fallout.Common` broke). Shim-package count now tracks **NUKE's real consumer packages**: `Nuke.Common` (references the `Fallout` meta and re-exports every `Nuke.Common.*` sub-namespace wherever the source type now lives across the rings) + `Nuke.Components`. **`Nuke.Build` is deleted** — never a real consumer package.
+ - **The generator is map-driven**: it emits the map rows whose `ShimPackage` equals the compiling assembly's name (replacing the per-assembly `[assembly: ShimAllPublicTypesUnder]` markers), with longest-Fallout-prefix-wins ownership so split namespaces (CI/ProjectModel/IO) don't double-emit.
+ - **Cake migration support is dropped** (low demand; the original author's feature). Nuke→Fallout is the supported migration; even that is kept deliberately lightweight given current demand.
+ - Validated by re-including the previously-excluded compat tests (`Nuke.Common.Shim.Tests`, `Nuke.Consumer`) — a pure NUKE consumer surface compiles through the 2 shims. **This closes the realignment**: the onion is structurally complete and NUKE-compat is restored.
+
+## References
+
+- Current-state map: see the structural survey summarized in the spike.
+- Shim machinery: `src/Fallout.SourceGenerators/TransitionShimGenerator.cs`, `src/Shims/Nuke.*`
+- Migrate codefix: `src/Fallout.Migrate`, `src/Fallout.Migrate.Analyzers`
+- Deferral being amended: `docs/rebrand-plan.md` §"What's deliberately deferred"
+- Spike: [docs/spikes/0002-onion-domain-ring.md](../spikes/0002-onion-domain-ring.md)
diff --git a/docs/adr/README.md b/docs/adr/README.md
index c38f1e8d8..42a79817d 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -38,3 +38,4 @@ If you change a decision, do NOT silently rewrite the old ADR — add a new one
| [0002](0002-v11-off-nuget-by-default.md) | v11 publishes to GitHub Packages by default; nuget.org opt-in | Accepted |
| [0003](0003-variables-and-substitution.md) | Variables and `${…}` substitution layer | Proposed |
| [0004](0004-calendar-versioning-and-dual-pace-channels.md) | Calendar versioning + dual-pace channels (edge/stable) + experimental APIs | Accepted |
+| [0006](0006-onion-layering-and-namespace-realignment.md) | Onion layering + namespace realignment | Proposed |
diff --git a/docs/spikes/0002-onion-domain-ring.md b/docs/spikes/0002-onion-domain-ring.md
new file mode 100644
index 000000000..336dde2dc
--- /dev/null
+++ b/docs/spikes/0002-onion-domain-ring.md
@@ -0,0 +1,69 @@
+# Spike 0002 — Onion realignment: prove the Domain ring
+
+- **Status:** Done (2026-05-31) — see [Verdict](#verdict)
+- **Date:** 2026-05-31
+- **Decision record:** [ADR-0006](../adr/0006-onion-layering-and-namespace-realignment.md)
+- **Channel:** `experimental` (spike branch `spike/onion-structure`)
+- **Time-box:** one focused session
+
+> The full realignment (ADR-0006) is a large, breaking, ring-by-ring program. This spike does **only the innermost ring** — extract `Fallout.Domain` — to prove the three mechanics every later ring depends on, before committing to the larger ones. Throwaway-by-default.
+
+## Hypothesis
+
+> The pure-domain types can be lifted into a `Fallout.Domain` layer (`namespace = project = layer`) such that: (1) the Domain assembly references **no other Fallout assembly**, enforced by a fitness test; (2) the solution still builds and all tests pass — confirming the move + reference-fixup + fitness loop that the Application and Infrastructure rings will reuse at larger scale.
+
+## Scope
+
+### In scope
+1. **Create `Fallout.Domain`** (project + namespace). Move into it the pure-domain types: `Fallout.Core.Planning.*` (graph/topo-sort/cycle detection) and the domain types currently under `Fallout.Common.Execution` in the `Fallout.Core` project (`ITargetModel`, `ExecutionStatus`). Result: `Fallout.Core` is renamed/absorbed; no domain type remains under `Fallout.Common.*`.
+2. **Fitness test.** Assert `Fallout.Domain` references no other `Fallout.*` assembly (the innermost-ring invariant). Demonstrate it fails on an injected violation, then revert.
+3. **Update internal references.** `Fallout.Application`-to-be (currently `Fallout.Build`) and others that consumed the moved types via `Fallout.Common.Execution` now reference `Fallout.Domain`.
+
+### Out of scope
+- ❌ The Application and Infrastructure rings (later PRs).
+- ❌ Renaming `Fallout.Build` → `Fallout.Application`, dissolving `Fallout.Common`, moving tools/CI/utilities — none of it yet.
+- ❌ **Shim / migration parity — deferred wholesale** (ADR-0006). We do *not* re-point the `TransitionShimGenerator` here; the `Nuke.*` surface is allowed to lapse on `experimental`. The migration strategy is redesigned as its own phase once the target shape settles.
+- ❌ Consumer-template global usings (an Application/Infrastructure-ring concern).
+
+## Ordered steps
+
+1. Branch is `spike/onion-structure` off `experimental`. (Done.)
+2. Read the current `Fallout.Core` contents and every reference to its types across the solution (esp. `Fallout.Common.Execution` consumers in `Fallout.Build`).
+3. Create `Fallout.Domain` project; move the pure-domain files; set `namespace = Fallout.Domain[.Planning]`.
+4. Fix references (project refs + `using`s) across the solution. The `Nuke.*` shim build may break here — that's expected and allowed (shim parity deferred); if it blocks the solution build, temporarily exclude the affected shim project rather than re-pointing it.
+5. Add the Domain-ring fitness test; confirm green, then confirm it goes red on a deliberate `Fallout.*` reference, then revert.
+6. Validate: `./build.sh Compile` + `./build.sh Test` (or the per-project equivalents) green; dogfood workflows unchanged.
+
+## Success criteria
+- ✅ `Fallout.Domain` exists; no domain type remains under `Fallout.Common.*`.
+- ✅ Fitness test passes and demonstrably fails on a violation.
+- ✅ Solution (excluding deferred shim parity) builds; tests green.
+- ✅ A written verdict: did the move + reference-fixup + fitness loop hold? What surprised us? Is it safe to scale to the Application ring (the big one — the user-facing API rename)?
+
+## Risks / watch
+- **What's *really* domain.** `Fallout.Core` already mixes `Fallout.Core.Planning` and `Fallout.Common.Execution` — move only genuinely-pure types; anything touching execution *orchestration* (not the model) belongs in the Application ring, not Domain.
+- **Hidden inward references.** A "domain" type that secretly reaches into utilities/IO would break the zero-deps invariant — the fitness test will catch it; treat any such case as a finding about what's really domain. This is now the spike's primary unknown (the shim question is deferred out).
+- **Shim fallout is expected, not a failure.** If moving types breaks the `Nuke.*` shim build, that's the deferred concern surfacing — note it and move on; do not rabbit-hole on re-pointing.
+
+## Exit
+Set **Status: Done**, append the verdict, and feed it back into ADR-0006 (confirm/adjust the layer mapping, then promote `Proposed` → `Accepted`) before starting the Application ring.
+
+## Verdict
+
+**Hypothesis confirmed.** The move → reference-fixup → fitness loop holds. `Fallout.Domain` exists, no domain type remains under `Fallout.Common.*`, the solution builds, and the **full test suite passes** (every project, including the `Nuke.*` shim tests).
+
+**What landed (commit `refactor(arch)!: extract Fallout.Domain ring`):**
+- `Fallout.Core` → `Fallout.Domain` (project + test project, via `git mv`); refs in `Fallout.Build.csproj`, the test csproj, and `fallout.slnx` updated.
+- The two mis-namespaced execution types (`ITargetModel`, `ExecutionStatus`) moved out of `Fallout.Common.Execution` → `Fallout.Domain.Execution`; `Fallout.Core.Planning` → `Fallout.Domain.Planning`.
+- 8 consumers in `Fallout.Build`/tests gained `using Fallout.Domain.Execution;`; the intra-repo `ExecutionStatus` **type-forwarder re-pointed**.
+- Fitness test **strengthened**: Domain must depend on no outer ring *including `Fallout.Common`* (the realignment goal). Passes; proven red on an injected dependency, then reverted.
+
+**Findings that shape the bigger rings:**
+1. **Head start that won't repeat.** `Fallout.Core` was already pure with an existing fitness test (issue #88's seed). The Domain ring was therefore a *rename*, not a purity fight. The Application/Infrastructure rings start from the `Fallout.Common.*` tangle — expect real work, not just renames.
+2. **Shim breakage is SILENT, not fatal — good news for the deferred strategy.** Moving types out of `Fallout.Common.*` doesn't fail the shim build; the `TransitionShimGenerator` simply stops mirroring them into `Nuke.*` (it only maps the `Fallout.Common` prefix). The solution built and the shim tests passed. So the rings won't be *blocked* by shim breakage — the `Nuke.*` surface just quietly shrinks, to be rebuilt by the deferred migration phase. **Caveat:** this was 2 types (one an enum the generator skips anyway). The **Application ring** moves the user-facing API *en masse* — the silent surface reduction there will be large; still expected to be build-clean.
+3. **Blast radius beyond namespaces is real but mechanical.** Two non-obvious things needed updating: an **intra-repo type-forwarder** and a **Verify snapshot** (the solution-generator emits project names, so renaming projects churns it). The Application/Infrastructure rings will hit *many* more consumers and likely more snapshots — same loop, larger N.
+4. **Splitting a shared namespace costs double-usings.** Because `Fallout.Common.Execution` keeps its orchestration types (staying → future `Fallout.Application.Execution`) while the model types left, consumers need *both* usings transiently. The Application ring (whole-namespace move) should be more uniform but far larger — **worth a bulk using-rewrite tool** (or lean on the `Fallout.Migrate` codefix machinery).
+
+**Safe to scale to the Application ring** — the mechanics are proven. That ring is the big one (the user-facing `FalloutBuild`/`Target`/`[Parameter]` rename); recommend it as its own PR, with a bulk using-rewriter prepared first.
+
+*Residual nit:* `src/Fallout.Domain/README.md` may still contain `Fallout.Core` prose — cosmetic, sweep during the Application ring.
diff --git a/docs/spikes/0003-onion-infrastructure-ring.md b/docs/spikes/0003-onion-infrastructure-ring.md
new file mode 100644
index 000000000..f849fc02c
--- /dev/null
+++ b/docs/spikes/0003-onion-infrastructure-ring.md
@@ -0,0 +1,108 @@
+# Spike 0003 — Onion realignment: the Infrastructure ring (steps 3–5)
+
+- **Status:** ✅ STRUCTURALLY COMPLETE. step 3, 4a, 4b + inversion, 5a, 5b, 5c done; 5d resolved-by-decision; project-FILE renames + splits + meta-package done; namespace residuals cleaned; **`Nuke.*` shim + Migrate redesign DONE** (the last deferred item). The whole onion is `ring = project = namespace = assembly = package`, and the NUKE-compat story (shims + migration) is rebuilt on a single canonical map. Remaining: only shipping the stack. On branch `spike/shim-migration-redesign` (stacked on `spike/onion-kernel`).
+- **Shim + Migration redesign DONE (2026-06-01, branch `spike/shim-migration-redesign`):** one canonical **`src/Shared/NukeNamespaceMap.cs`** (Nuke↔Fallout namespace rows + a package-ID map) now drives BOTH halves, which the onion had desynchronised: the `TransitionShimGenerator` (Fallout→Nuke re-exports, map-driven by the compiling assembly's name, longest-prefix-wins) and the migration rewriters (`CodeRewriter`/`CsprojRewriter`/`NukeMigrationCodeFix`, Nuke→Fallout — previously a blind `Nuke.`→`Fallout.` swap that produced dead `Fallout.Common.*`). **Shim packages 3→2**: `Nuke.Common` (references the `Fallout` meta, re-exports every `Nuke.Common.*` sub-namespace wherever the source now lives) + `Nuke.Components`; **`Nuke.Build` deleted** (never a real NUKE consumer package). **Cake migration support dropped entirely** (low demand). Compat tests (`Nuke.Common.Shim.Tests`, `Nuke.Components.Shim.Tests`, `Nuke.Consumer`) re-included as the validation — a pure NUKE consumer surface compiles through the 2 shims. Full suite + dogfood `./build.sh Test` green.
+- **Project renames/splits DONE (6 phases, commits a5e85646 / df09f573 / 94d31883 / 01d4a670 / 3ed3a645 + this):** (1) pure renames `Fallout.Build`→`.Application`, `Components`→`.Application.Components`, `ProjectModel`→`.Infrastructure.ProjectModel`, `Utilities*`→`Kernel*`; (2) split `Tooling`→`Application.Tooling`+`Infrastructure.Tooling`; (3) split `Solution`→`Application.Solutions`+`Infrastructure.Solutions`; (4) dissolve `Fallout.Common`→`Application.Tools`+`Infrastructure.CI`+`Application`+`Kernel`, new thin **`Fallout` meta-package** as the consumer anchor (carries `Fallout.props`/`.targets`+MSBuildTasks+analyzer); (5) TFM cleanup (net472 dropped; Domain→net10.0; ProjectModel KEEPS net8/9/10 — per-TFM MSBuild SDK matching; ns2.0 only where Roslyn generators consume). **Linchpin fix:** `Assembly.Load` doesn't run `[ModuleInitializer]`s, so split-out adapter registration silently broke (null `ToolingServices`/`SolutionServices`, swallowed NRE — invisible to unit tests, caught by the dogfood build); `BuildManager.Initialize` now `RunModuleConstructor`s each Fallout.* assembly, the generator uses a `SolutionReader` direct-read, and test hosts force-run the adapter module ctors. Full suite (14 projects) + gate + dogfood `./build.sh Test` green throughout.
+- **Namespace residuals CLEANED (2026-06-01, commits 2f205744 + 2b289e08):** (1) the `Kernel.IO`-namespace files in the Application assembly (FtpTasks/HttpTasks/globbing attrs) → `Fallout.Application.IO` (namespace now matches assembly; the 20 genuine Kernel.IO types in Fallout.Kernel untouched). (2) the last surviving `Fallout.Common` namespace (`Constants`/`LegacyEnvironment` in Build.Shared) → `Fallout.Build.Shared`; a vestigial `Fallout.Common.FalloutBuild` stub in SourceGenerators deleted first so the namespace fully evacuated (75 dead usings dropped) + the starter template's dead `using Fallout.Common;` removed. **`Fallout.Common` no longer exists anywhere in shipped code** (only as Nuke→Fallout migration test DATA in Migrate fixtures). The onion is now truly `ring = project = namespace = assembly = package`. Only remaining onion work: the `Nuke.*` shim / Migrate redesign.
+- **Date:** 2026-05-31 (updated 2026-06-01)
+- **Decision record:** [ADR-0006](../adr/0006-onion-layering-and-namespace-realignment.md)
+- **Channel:** `experimental` (branch `spike/onion-infrastructure`)
+
+> Handoff doc for picking up the onion realignment next session. Captures the whole workstream's
+> state, the decisions already made, the reusable tooling, and the precise next steps.
+
+## Where the whole realignment stands
+
+Onion layers, `namespace = project = layer`, **breaking, whole-onion in the 2026 major** (the 2026
+major hasn't cut; breaking work rides it — ADR-0006). Branch stack on `experimental`:
+
+```
+experimental
+ └─ spike/onion-structure Domain ring (step 1) → PR #343 (target/2026, breaking)
+ └─ spike/onion-application Application ring (step 2) → PR #349 (stacks on #343, breaking)
+ └─ spike/onion-infrastructure Infra ring (3–5) → (unpushed; step 3 committed)
+```
+
+(Also open, unrelated-ish: PR #341 = CI ports/adapters, additive; PR #342 = other maintainer's promote.)
+
+### Done
+1. **Domain ring** — `Fallout.Core` → `Fallout.Domain`; `ITargetModel`/`ExecutionStatus`/`Planning` out of `Fallout.Common.*`. Fitness test: Domain depends on no outer ring. (PR #343)
+2. **Application ring** — everything `Fallout.Build` declared under `Fallout.Common.*` (`FalloutBuild`, `Target`, `[Parameter]`, `Host`, engine, value injection, CI ports) → `Fallout.Application.*`. ~297 files, full suite green (~450 tests). (PR #349)
+3. **Infra step 3 — execution port** — `IProcessRunner` + `SystemProcessRunner` + `ProcessTasks.Runner` seam; the impure `Process.Start` is now behind the port. Tooling vocabulary can now be pure. (committed on this branch; 64/64 Tooling tests)
+
+### Done (cont.)
+4a. **Components → Application** — `Fallout.Components` (20 files, single namespace) → `Fallout.Application.Components`. Clean isolated move; full suite green. Shim repointed (see below). Confirmed the generalized rule-table rewriter on an easy target before the hard Tooling move.
+
+4b. **Tool vocabulary → Application; executor → Infrastructure** — the entangled one. `Fallout.Common.Tools.*` → `Fallout.Application.Tools.*`; the `Fallout.Common.Tooling` namespace (shared across `Fallout.Tooling` + `Fallout.Common`, mixing vocabulary and executor in one namespace) splits **per type**: vocabulary + ports + attributes + `ProcessException` → `Fallout.Application.Tooling`; the 13 impure executor types (`ProcessTasks`, `SystemProcessRunner`, `Process2`, `ProcessExtensions`, `ToolExecutor`, `ToolPathResolver`, `NuGet*`/`Npm*`/`Paket*` resolvers, `ToolingExtensions`) → `Fallout.Infrastructure.Tooling`. **Maintainer chose "true homes, defer port fix"**: types land where they belong, accepting `ToolTasks`(App)→`ProcessTasks`(Infra) + resolver I/O as a tracked Application→Infrastructure dependency to be inverted behind ports in a follow-up (no fitness test guards it yet — projects aren't split). 271 files, full suite green (7 cake-migration snapshots re-accepted — namespace-only churn). The prefix-only rewriter grew **per-type overrides** + **multi-assembly rules** + **lost-ancestor usings** + **cref rewriting** (lessons #8–#11). `AbsolutePath`/`Fallout.Common.IO` deferred to step 5 (still `Fallout.Common.IO` here, so no ring crossing yet — they'll need a shared kernel when IO moves).
+
+### Done (cont.)
+**4b-follow-up — port inversion + Application-ring fitness gate.** Ports in `Fallout.Application.Tooling` (`IProcessExecutor`, `IToolPathResolver`, `IToolVersionResolver`) behind a `ToolingServices` locator; Infrastructure registers thin adapters via a `[ModuleInitializer]` (polyfilled for the `netstandard2.0` TFM). All ~18 Application-ring call sites (process exec, path/package/version resolution, the config-push from `BuildManager`/`ToolRequirementService`) routed through the ports. `ProcessExtensions` reclassified Infra→`Application.Tooling` (it's pure `IProcess`/`Output` vocabulary the App ring calls everywhere — a 4b mis-classification). New `tests/Fallout.Architecture.Tests` runs a NetArchTest gate: `Fallout.Application.*` ⊥ `Fallout.Infrastructure.*` (green). Lessons learned: the fitness test must live in its OWN project — loading every ring's assembly into a project that also has `AppDomain.GetAssemblies()`-scan tests (e.g. `SchemaUtilityTest` in `Fallout.Build.Tests`) perturbs those snapshots; and extension methods are silent cross-ring deps the grep misses — the gate (IL analysis) is the real oracle.
+
+Catch-all `Fallout.Common.*` code outside the Application ring (CI host adapters, `HandleSingleFileExecution`/`CheckPathEnvironmentVariable` attributes, `Fallout.Cli` composition root, `Fallout.MSBuildTasks`) still reaches Infrastructure — out of the gate's scope; folds in with step 5 as those namespaces get rings.
+
+### Done (cont.) — straggler cleanup (2026-06-01)
+**Finished partial onion moves left by earlier steps** (surfaced while cleaning the Cli cake-migration + project template). Two OnionRewriter passes:
+- **Git + ChangeLog → Application** (commit cc9acf84): `GitRepositoryAttribute` (`Fallout.Common.Git`) joined the `GitRepository` model already in `Fallout.Application.Git`; changelog helpers `Fallout.Common.ChangeLog` → `Fallout.Application.ChangeLog`. No shim-marker change — the Application ring's `Nuke.*` shim story is the deferred redesign, so this just aligns Git/ChangeLog with it.
+- **5a Kernel stragglers → `Fallout.Kernel`** (commit 58100f66): `EnvironmentInfo` (5 files), `Assert`, `AsyncHelper`, `ArgumentParser` were still in `namespace Fallout.Common` inside the `Fallout.Utilities` (Kernel) project — 5a missed them (lesson #12). Moved via a **separate pass with source assembly = `Fallout.Utilities` only**, so the surviving-namespace scan keeps the Fallout.Common project's surviving root types and doesn't drop live `using Fallout.Common;`. ~180 files of ref churn. Two rewriter blind-spots hand-fixed: (a) `Fallout.ProjectModel` files carried a `using Fallout.Common;` that only resolved because Utilities *declared* those Common types — once moved, the using dangled (CS0234) since ProjectModel doesn't reference the Fallout.Common assembly; the rewriter can't see assembly-ref graphs. (b) `CITest.cs` gained `using Fallout.Kernel;` (for `.NotNull()`), colliding `Fallout.Kernel.Assert` with `Xunit.Assert` → aliased to Xunit's. Full suite + dogfood green.
+- **Execution + Gitter tail → Application** (commit d38acb78): `Fallout.Common.Execution` (the `CheckPathEnvironmentVariable` + `HandleSingleFileExecution` build-extension attributes) → `Fallout.Application.Execution`; `Fallout.Common.Gitter` (`GitterTasks`) → `Fallout.Application.Tools.Gitter` (joins the sibling notification tools). **The fitness gate earned its keep here**: moving the two attributes into the Application namespace exposed a real Application→Infrastructure dependency that was previously invisible (they called `ProcessTasks` from `Fallout.Infrastructure.Tooling` directly — the spike had flagged they "still reach Infrastructure"). Rerouted through the `IProcessExecutor` port (`ToolingServices.Process`), the same 4b inversion the rest of the ring uses. After this, no `Fallout.Common.{Git,ChangeLog,Execution,Gitter}` references remain. (Still partial, not pursued: the `Fallout.Common` root retains a handful of catch-all types — `Constants`, `Configuration`, etc.)
+
+### Remaining (this ring) — step 5, now sub-divided
+**Kernel decision (maintainer, 2026-06-01): a new `Fallout.Kernel`** — innermost shared ring below Application; Domain/Application/Infrastructure all depend on it. Pure shared value-types live here so the Application ring keeps compiling when IO moves outward (else the new fitness gate fails). Sub-steps:
+- **5a — `Fallout.Kernel`** ✅ DONE (namespace move; 437 files, green; gate still passes). The foundational move. **Filesystem-line decision (maintainer, 2026-06-01): filesystem IS a kernel-level capability** (like the BCL's `File`/`Directory`) — Kernel keeps `AbsolutePath` *and* its fluent file ops (`.ReadAllText`/`.GlobFiles`/`.CreateDirectory`/…); only the genuinely-EXTERNAL adapters go to Infrastructure (HTTP/FTP = `Fallout.Utilities.Net` + `Common.IO` Http/Ftp tasks; compression = `Fallout.Utilities.IO.Compression`). Rationale: the fluent `AbsolutePath` API is used pervasively across the Application ring; routing it through an `IFileSystem` port would be hundreds of call sites and kill the ergonomics, and putting it in Infrastructure would fail the new Application-ring fitness gate.
+ - **Kernel contents** (~65+ files): all pure Utilities (`Collections`, `Text`/string, `Reflection`, `Assert`/`AsyncHelper`/`ArgumentParser`/`EncryptionUtility`/`ResourceUtility`/…); `AbsolutePath`/`RelativePath`/`PathConstruction` + ALL `AbsolutePath` extensions incl. filesystem; `EnvironmentInfo` (whole); `Globbing`; `GlobbingCaseSensitivity`. Namespaces `Fallout.Common.Utilities*`/`Fallout.Common.IO` → `Fallout.Kernel.*`.
+ - **To Infrastructure**: `Fallout.Utilities.Net` (HTTP), `Fallout.Utilities.IO.Compression`, and `Common.IO`'s `HttpTasks`/`FtpTasks`. The `Common.IO` namespace thus SPLITS per-type (filesystem→Kernel, Http/Ftp→Infra) — needs the rewriter's per-type overrides again.
+ - **Caveats**: `AbsolutePathExtensions` is one partial class across ~11 files — it must move WHOLE (can't span assemblies), so it goes entirely to Kernel (fine, since filesystem=Kernel). **This is the first step that creates a NEW PROJECT / relocates files** (vs. the namespace-only moves of 4a/4b) — likely realized by renaming the existing `Fallout.Utilities` project → `Fallout.Kernel` and consolidating the IO bits, which overlaps the "project-file renames" deferred work. `Fallout.Domain` will gain a dependency on `Fallout.Kernel` (Kernel is innermost-shared). No back-references found from Utilities/IO into Domain/App/Infra (clean to move).
+- **5b — CI adapters**: `Fallout.Common.CI.` → `Fallout.Infrastructure.CI.*`.
+- **5c — ProjectModel/Solution** ✅ DONE (full onion; commits 9548a948 phase A, c6a3cb5d phase B, fea66fa3 phase C–E). **Maintainer chose the most faithful realization: a Fallout-OWNED model + ports in the inner ring, concrete impls outside.** Reality differed from the original guess in two ways: (1) the earlier "~5 Application callers" of the MSBuild surface were almost all FALSE POSITIVES (Reflection/JSON `.GetProperty`); the only gated callers were `Telemetry.CheckAwareness` (dead code, telemetry disabled) and `Components/ITest.HasPackageReference`. (2) The vendored `Fallout.Persistence.Solution` `.Model` ↔ `.Serializer` are MUTUALLY entangled (bidirectional via `ISerializerModelExtension`), so the lib can't be split — the whole vendored tree is reached only through the Infrastructure adapter.
+ - **Shape**: `Solution`/`Project`/`SolutionFolder`/`SolutionItem`/`IProjectContainer`/`SolutionAttribute`/`ReadSolution`/ports → `Fallout.Application.Solutions`. The model is a Fallout-owned **POCO tree** (was a live wrapper over the vendored `SolutionModel`); it holds an **opaque `object Handle`** carrying the vendored model for `Save` round-trip fidelity without naming a vendored type (so the gate passes; `Solution.Save`/`GetModel` have zero consumers anyway). Two ports — `ISolutionSerializer` (open/save across .sln/.slnx) + `IProjectEditor` (MSBuild get/set property + HasPackageReference). Serializer adapter + vendored→Fallout translation walker → `Fallout.Infrastructure.Solutions`; MSBuild evaluator (`ProjectModelTasks`/`ProjectExtensions`/`ProjectEditorAdapter`) → `Fallout.Infrastructure.ProjectModel`.
+ - **Co-hosting (deviation from the written plan, deliberate)**: adapters co-hosted with the model in the existing project files (like `Fallout.Tooling`) rather than a new `Fallout.Infrastructure.Solutions` project — guarantees the `[ModuleInitializer]` registration runs (no separate-assembly load-ordering bug) AND makes the build-time source generator's compile-time `ReadSolution` work unchanged (the generator already bundles the model DLL). Physical project-file split stays deferred with the other renames. The gate enforces the ring boundary by NAMESPACE regardless of project.
+ - **Consumer cost** (per ADR-0006's accepted "public API under Infrastructure"): the MSBuild project-query extensions (`GetTargetFrameworks` etc.) no longer flow transitively — the Cli composition root + the dogfood build now reference `Fallout.ProjectModel` directly.
+ - **Pre-existing debt found, NOT fixed (out of 5c scope)**: `src/Fallout.Cli/Rewriting/Cake/ClassRewriter.cs`'s hard-coded `using` list + `src/Fallout.Cli/templates/Build.cs` still carry stale `Fallout.Common.*` namespaces from steps 4a/4b/5b (the semantic rewriter never touches string literals / embedded-resource templates). The cake-migration output + `dotnet fallout` template are therefore emitting dead namespaces — a separate cleanup.
+- **5d — external IO** ✅ RESOLVED BY DECISION (maintainer, 2026-06-01): **kept in Kernel — no code moves.** Extends the 5a "filesystem is kernel-level" ruling to the rest of the external-IO *fluent vocabulary*. Investigation found every external-IO category the original plan earmarked for Infrastructure is consumed by **gated Application-ring** code, so none can move cleanly and all would otherwise need 5c-style ports:
+ - **HTTP fluent client** (`Fallout.Kernel.Net` — `HttpClient.CreateRequest(...).Send()` extensions over the BCL `HttpClient`) ← `Fallout.Application.Tools.*` (Slack/Discord/Teams/Mastodon/Gitter). A thin BCL-ergonomic layer, structurally identical to the filesystem-over-BCL case → **stays in Kernel.**
+ - **Compression** (`.ZipTo()`/`.UnZipTo()`, `Fallout.Kernel.IO`) ← `Fallout.Application.Components/ISignPackages`. These are **`AbsolutePath` extension methods** — part of the very fluent `AbsolutePath` API 5a already kept in Kernel; porting them kills the same ergonomics → **stays in Kernel.**
+ - **`HttpTasks`/`FtpTasks`** (download-URL-to-file, `Fallout.Kernel.IO`) ← `Fallout.Application.Tooling` (`LatestMaven`/`LatestMyGet` version-resolver attrs) + `Fallout.Common.Execution` (catch-all). The one genuinely-coarse "network task" category → **kept in Kernel for now**; a small `IHttpDownload`-style port → Infrastructure remains *optional* future work if we want strict external-IO purity, but it is not required for the gate and is deferred.
+ - **Glob** (`.GlobFiles`, `Fallout.Kernel.Globbing`) — already part of the fluent `AbsolutePath` API, kernel-level by 5a. No change.
+ - Net effect: 5d moves nothing; `Fallout.Utilities.Net`/`Fallout.Utilities.IO.Compression`/`Fallout.Utilities.Globbing` remain Kernel-ring assemblies (their project-FILE consolidation into the `Fallout.Kernel` project is the deferred rename work, not a ring crossing). Gate (`Application ⊥ Infrastructure`) stays green.
+5. **I/O adapters → Infrastructure** (original framing; superseded in part) — CI host adapters (`Fallout.Common.CI.`) → `Fallout.Infrastructure.CI.*` ✅ (5b); the `ProcessTasks`/`ToolExecutor` executor side → `Fallout.Infrastructure` ✅ (4b); `Fallout.ProjectModel`/`Fallout.Solution` → `Fallout.Infrastructure.*` (5c, via ports). **NOT moving:** `Fallout.Common.IO` + `Fallout.Utilities.IO/.Net/.Compression/.Globbing` — these are the fluent external-IO vocabulary and stay in Kernel (5a + 5d decisions), *not* Infrastructure.
+
+### Design decisions already made (don't relitigate)
+- **Layer names**: explicit onion (`Fallout.Domain`/`.Application`/`.Infrastructure`, `Fallout.Cli` root). Public tool/CI API lives under `.Infrastructure` (accepted; ease consumer ergonomics later with template global usings).
+- **Tool wrappers = Application vocabulary** (not Infrastructure): they're pure command builders; execution is the port. `Components` folds into Application (it composes wrappers).
+- **Utilities split**: pure helpers (collections, reflection, string) → a **shared kernel below Application** (a small `Fallout.Kernel`-style project that Application + Infrastructure depend on; Domain stays zero-dep). Genuine I/O → `Fallout.Infrastructure.*`.
+- **Shipping**: breaking → `experimental` → 2026 major. Shim/migration redesigned at the END (deferred).
+
+## The reusable tool: `tools/OnionRewriter`
+
+Semantic namespace mover (MSBuildWorkspace + symbol resolution). Run: `dotnet run --project tools/OnionRewriter` (dry-run) / `-- --apply`. It rewrites namespace declarations in a source project, fixes references repo-wide by the symbol each binds to, and reconciles `using`s.
+
+**Generalized (done for step 4a)**: now driven by a `Rule[]` table — each rule is `(OldPrefix, NewPrefix, SourceAssembly)`, collected across *multiple* source assemblies. Edit the table per step (step 4a = the single Components rule). `IsMovable`/`MapNs`/`IsSourceFor` derive from the table; moved-type collection and the surviving-namespace scan iterate all source projects (source dirs derived from the loaded projects, not hard-coded). Steps 4b/5 just add rules — except `Fallout.Common.IO` is declared across **four** assemblies (Common + Utilities + Utilities.IO.Compression/Globbing), so that move needs one rule per declaring assembly (or generalize `SourceAssembly` to a set).
+
+**Companion (non-semantic) edits the rewriter does NOT do** — it operates on symbols, never string literals, so per step also update by hand: transition-shim **`ShimMarker.cs`** `fromNamespacePrefix` strings (the `ShimAllPublicTypesUnder` source prefix — load-bearing: the shim generator mirrors that prefix, so a stale value silently stops emitting the shims and the hand-written `IHaz*` aliases fail to compile); any Migrate rename-map strings; Verify snapshots that embed names.
+
+### Hard-won tool lessons (bake these into the generalized version)
+These edge cases each cost a build cycle on the Application ring — the generalized tool must keep them:
+1. **Classify moved types by assembly NAME + a moved-set membership** (not symbol identity — a referenced project's assembly symbol is a *different instance* per compilation, so identity comparison fails cross-project). Combine with skipping package-consumer projects to avoid the `Fallout.Build`-named NuGet package collision.
+2. **Skip package consumers** (`Consumer.NuGet`, `Nuke.Consumer`) — they compile against the published package, not local source.
+3. **Detect non-type references too**: attribute names bind to the **constructor** (`IMethodSymbol`), extension calls (`x.NotNull()`) bind to the **reduced method** — take the declaring type in both, else their `using`s are missed.
+4. **Nested-type qualified refs** (`Ns.Outer.Nested`): only remap a qualified name's `Left` when it equals the type's namespace exactly; let the inner qualified-name visit handle nested cases (else you drop the outer-type qualifier).
+5. **`using` drop rule**: drop a movable `using` when its namespace is **fully evacuated** (no residual declarations anywhere — would dangle) OR when a moved type was imported from it and no residual type still is. Don't touch pre-existing unused usings of surviving namespaces.
+6. **Source files that change namespace** lose same-namespace access to **residual** siblings — add explicit `using`s for the residual movable namespaces they use (e.g. a file leaving `Fallout.Common` still using a `Fallout.Common`-residual helper).
+7. **Snapshots churn**: the solution generator + cake-migration Verify snapshots embed namespaces/project names — accept the `.received` after applying. Excluding shim consumer/test projects from `fallout.slnx` also churns the solution-generator snapshot. (Step 4a churned none — project *names* were unchanged, only the namespace.)
+8. **Classify moved types by their OUTERMOST enclosing type, not the symbol's own name** (found on 4a): a *nested* type's `ContainingNamespace` is the enclosing namespace, so a `{ns}.{Name}` lookup in the moved-set (top-level names only) misses it → it's misclassified as *residual*, which for a source file adds a `using` of the very namespace the move evacuates (dangling → CS0246). Fix: walk `ContainingType` to the top, key the moved-set check on that. Belt-and-suspenders: never add a residual `using` for a namespace not in `surviving`.
+9. **Per-type overrides split one namespace across rings** (4b): `Fallout.Common.Tooling` holds both vocabulary (→Application) and executor (→Infrastructure). Prefix rules can't split a namespace, so the mapping became per-TYPE: `targetNs(type)` (override map beats prefix rule) replaced the per-namespace `mapNs`. Namespace *declarations* map by the moved types they declare (`MapDecl` — first moved type wins; blocks are single-ring since each type is its own file).
+10. **Lost-ancestor usings** (4b — generalises #6 to non-movable parents): a file in `A.B.C` implicitly sees `A.B`/`A` with no `using`. Moving it to `X.Y.Z` severs that — e.g. `Fallout.Common.Tooling.*` files used `EnvironmentInfo`/`NotNull`/`Assert` from the **`Fallout.Common` root** with no import; after the move they need an explicit `using Fallout.Common;`. Fix: for a source file whose namespace changes, add a `using` for each strict ancestor of the old namespace that is (a) not an ancestor of the new namespace and (b) actually used. **This is the one that costs a whole build cycle if missed** (~160 CS0103/CS1061).
+13. **Alias-qualified names (`global::Ns.Type`) aren't rewritten** (5b): `VisitQualifiedName` compares `node.Left.ToString()` to the symbol's plain namespace, but `global::Fallout.Common.CI.X.X` has Left = `global::Fallout.Common.CI.X` (with the `global::` alias), so the exact match fails and the ref is left stale. Hit in the Nuke.Common CI host shims (hand-written `global::Fallout.Common.CI..
` aliases). Fix: strip a leading `global::` before the comparison; for now mopped up by hand. (5b shape: provider classes → Infrastructure.CI, but the Application ring uses provider-SPECIFIC APIs — so per-provider ports `IAppVeyor`/… + a `CiHost` accessor casting `Host.Instance`, rather than one fat IBuildHost; no module-init needed since Host.Instance is the existing detection seam.)
+12. **The rewriter can silently miss files when a project fails to fully load** (5a): MSBuildWorkspace didn't analyse a handful of files (Fallout.Tooling/Build.Shared edge cases), leaving ~28 stale refs to a fully-evacuated namespace. A blunt repo-wide `sed` to mop them up OVER-REACHED — it (a) rewrote package-consumer projects (`Consumer.NuGet`) that must keep the *published* namespaces, and (b) rewrote the **Migrate tool's** test-fixture expectations (the `Nuke.*`→`Fallout.Common.*` rebrand contract is separate from the onion moves and deferred), and (c) doesn't do the lost-ancestor `using` fix (§10), so a file whose own namespace changed lost access to `Fallout.Common`-root guards. Lesson: mop up residuals only in genuine source/consumer files, skip package consumers + Migrate fixtures, and re-add `using Fallout.Common;` where a moved file used root guards. Better: fix the workspace-load gap so the rewriter doesn't miss them.
+11. **Rewrite crefs too** (4b): doc-comment `` names live in structured trivia — neither the prescan nor the rewriter descends there by default, so cref imports dangle and FQN crefs in the *generated* tool wrappers go stale (~7,600 CS1574/CS1580, non-fatal but review-blocking). Fix: prescan with `descendIntoTrivia: true` (so cref-only type refs still get their `using`), and give the `SyntaxFixer` `visitIntoStructuredTrivia: true` (so qualified cref names remap like any other qualified name).
+
+## Next-session checklist
+1. (Optional) Merge the stack first: `#343` then `#349` onto `experimental`, then rebase `spike/onion-infrastructure`.
+2. ✅ `OnionRewriter` generalized — `Rule[]` table + per-type overrides + multi-assembly + lost-ancestor usings + cref rewriting. ✅ 4a Components and ✅ 4b Tools/Tooling (vocab→Application, executor→Infrastructure) committed, green.
+3. **Step 5** (CI/IO/ProjectModel/Solution → Infrastructure): add rules; decide where `AbsolutePath`/`Fallout.Common.IO` land (likely a shared `Fallout.Kernel` — Infrastructure would break the Application ring). `Fallout.Common.IO` spans 4 assemblies → one rule per declaring assembly. **Also** schedule the port-inversion follow-up for the 4b tracked violation.
+4. Add a `Fallout.Kernel` (or chosen name) for pure helpers; split `Fallout.Utilities` (pure → kernel, I/O → Infrastructure). Note `Fallout.Common.IO` spans 4 assemblies — one rule each.
+5. Apply (scope-then-apply); update each `ShimMarker.cs` `fromNamespacePrefix`; accept any Verify `.received`.
+6. **Last**: project-FILE renames — `Fallout.Build`→`Fallout.Application` assembly, `Fallout.Tooling` split; then the shim/migration redesign.
+
+## Exit
+Update **Status** as steps land; once steps 4–5 are applied and green, push `spike/onion-infrastructure` and open its PR (`target/2026` + `breaking-change`, base = `spike/onion-application` until the stack merges).
diff --git a/fallout.slnx b/fallout.slnx
index 0f6ae9699..55538988d 100644
--- a/fallout.slnx
+++ b/fallout.slnx
@@ -11,45 +11,55 @@
-
-
-
-
+
+
+
+
+
+
-
-
+
-
+
+
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
-
-
+
diff --git a/src/Fallout.Components/Configuration.cs b/src/Fallout.Application.Components/Configuration.cs
similarity index 82%
rename from src/Fallout.Components/Configuration.cs
rename to src/Fallout.Application.Components/Configuration.cs
index f55201c79..16495a695 100644
--- a/src/Fallout.Components/Configuration.cs
+++ b/src/Fallout.Application.Components/Configuration.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.ComponentModel;
using System.Linq;
-using Fallout.Common.Tooling;
+using Fallout.Application.Tooling;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
[TypeConverter(typeof(TypeConverter))]
public class Configuration : Enumeration
diff --git a/tests/Fallout.Components.Tests/Fallout.Components.Tests.csproj b/src/Fallout.Application.Components/Fallout.Application.Components.csproj
similarity index 62%
rename from tests/Fallout.Components.Tests/Fallout.Components.Tests.csproj
rename to src/Fallout.Application.Components/Fallout.Application.Components.csproj
index 35c626099..4a00acd03 100644
--- a/tests/Fallout.Components.Tests/Fallout.Components.Tests.csproj
+++ b/src/Fallout.Application.Components/Fallout.Application.Components.csproj
@@ -4,8 +4,9 @@
net10.0
+
-
+
diff --git a/src/Fallout.Components/ICompile.cs b/src/Fallout.Application.Components/ICompile.cs
similarity index 91%
rename from src/Fallout.Components/ICompile.cs
rename to src/Fallout.Application.Components/ICompile.cs
index 6bec3c673..1f936ba74 100644
--- a/src/Fallout.Components/ICompile.cs
+++ b/src/Fallout.Application.Components/ICompile.cs
@@ -1,15 +1,15 @@
-using System;
+using System;
using System.Collections.Generic;
using System.Linq;
-using Fallout.Common;
-using Fallout.Solutions;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
+using Fallout.Kernel;
+using Fallout.Kernel.Collections;
+using Fallout.Application.Solutions;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface ICompile : IRestore, IHasConfiguration
{
diff --git a/src/Fallout.Components/ICreateGitHubRelease.cs b/src/Fallout.Application.Components/ICreateGitHubRelease.cs
similarity index 89%
rename from src/Fallout.Components/ICreateGitHubRelease.cs
rename to src/Fallout.Application.Components/ICreateGitHubRelease.cs
index 7c386bdd2..c4043199e 100644
--- a/src/Fallout.Components/ICreateGitHubRelease.cs
+++ b/src/Fallout.Application.Components/ICreateGitHubRelease.cs
@@ -1,24 +1,24 @@
-using System;
+using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
-using Fallout.Common;
-using Fallout.Common.ChangeLog;
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Common.IO;
-using Fallout.Common.Tools.GitHub;
-using Fallout.Common.Utilities;
using Octokit;
+using Fallout.Application;
+using Fallout.Application.Tools.GitHub;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
-namespace Fallout.Components;
+using Fallout.Application.CI;
+using Fallout.Application.ChangeLog;
+namespace Fallout.Application.Components;
[ParameterPrefix(GitHubRelease)]
public interface ICreateGitHubRelease : IHasGitRepository, IHasChangelog
{
public const string GitHubRelease = nameof(GitHubRelease);
- [Parameter] [Secret] string GitHubToken => TryGetValue(() => GitHubToken) ?? GitHubActions.Instance?.Token;
+ [Parameter] [Secret] string GitHubToken => TryGetValue(() => GitHubToken) ?? CiHost.GitHubActions?.Token;
string Name { get; }
bool Prerelease => false;
diff --git a/src/Fallout.Components/IGlobalTool.cs b/src/Fallout.Application.Components/IGlobalTool.cs
similarity index 87%
rename from src/Fallout.Components/IGlobalTool.cs
rename to src/Fallout.Application.Components/IGlobalTool.cs
index 69447ffbd..d6273ec41 100644
--- a/src/Fallout.Components/IGlobalTool.cs
+++ b/src/Fallout.Application.Components/IGlobalTool.cs
@@ -1,11 +1,11 @@
using System;
using System.IO;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Tools.DotNet;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IGlobalTool : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasArtifacts.cs b/src/Fallout.Application.Components/IHasArtifacts.cs
similarity index 56%
rename from src/Fallout.Components/IHasArtifacts.cs
rename to src/Fallout.Application.Components/IHasArtifacts.cs
index 2e76d86d7..1900a11a5 100644
--- a/src/Fallout.Components/IHasArtifacts.cs
+++ b/src/Fallout.Application.Components/IHasArtifacts.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.IO;
+using Fallout.Application;
+using Fallout.Kernel.IO;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasArtifacts : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasChangelog.cs b/src/Fallout.Application.Components/IHasChangelog.cs
similarity index 60%
rename from src/Fallout.Components/IHasChangelog.cs
rename to src/Fallout.Application.Components/IHasChangelog.cs
index 1aeff4d5b..14f0f1177 100644
--- a/src/Fallout.Components/IHasChangelog.cs
+++ b/src/Fallout.Application.Components/IHasChangelog.cs
@@ -1,9 +1,10 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using static Fallout.Common.ChangeLog.ChangelogTasks;
+using static Fallout.Application.ChangeLog.ChangelogTasks;
+using Fallout.Application;
+using Fallout.Application.ChangeLog;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasChangelog : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasConfiguration.cs b/src/Fallout.Application.Components/IHasConfiguration.cs
similarity index 76%
rename from src/Fallout.Components/IHasConfiguration.cs
rename to src/Fallout.Application.Components/IHasConfiguration.cs
index c39fcd3cf..8ef5eef0c 100644
--- a/src/Fallout.Components/IHasConfiguration.cs
+++ b/src/Fallout.Application.Components/IHasConfiguration.cs
@@ -1,8 +1,8 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
+using Fallout.Application;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasConfiguration : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasGitRepository.cs b/src/Fallout.Application.Components/IHasGitRepository.cs
similarity index 60%
rename from src/Fallout.Components/IHasGitRepository.cs
rename to src/Fallout.Application.Components/IHasGitRepository.cs
index f88dc751f..4fb1ade8e 100644
--- a/src/Fallout.Components/IHasGitRepository.cs
+++ b/src/Fallout.Application.Components/IHasGitRepository.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Git;
+using Fallout.Application;
+using Fallout.Application.Git;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasGitRepository : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasGitVersion.cs b/src/Fallout.Application.Components/IHasGitVersion.cs
similarity index 61%
rename from src/Fallout.Components/IHasGitVersion.cs
rename to src/Fallout.Application.Components/IHasGitVersion.cs
index 7ae0e2e9e..81aa42d1f 100644
--- a/src/Fallout.Components/IHasGitVersion.cs
+++ b/src/Fallout.Application.Components/IHasGitVersion.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Tools.GitVersion;
+using Fallout.Application;
+using Fallout.Application.Tools.GitVersion;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasGitVersion : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasNerdbankGitVersioning.cs b/src/Fallout.Application.Components/IHasNerdbankGitVersioning.cs
similarity index 57%
rename from src/Fallout.Components/IHasNerdbankGitVersioning.cs
rename to src/Fallout.Application.Components/IHasNerdbankGitVersioning.cs
index d3edcebfc..bf86acad9 100644
--- a/src/Fallout.Components/IHasNerdbankGitVersioning.cs
+++ b/src/Fallout.Application.Components/IHasNerdbankGitVersioning.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Tools.NerdbankGitVersioning;
+using Fallout.Application;
+using Fallout.Application.Tools.NerdbankGitVersioning;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasNerdbankGitVersioning : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasReports.cs b/src/Fallout.Application.Components/IHasReports.cs
similarity index 63%
rename from src/Fallout.Components/IHasReports.cs
rename to src/Fallout.Application.Components/IHasReports.cs
index fe27dffc9..c3411fdb4 100644
--- a/src/Fallout.Components/IHasReports.cs
+++ b/src/Fallout.Application.Components/IHasReports.cs
@@ -1,8 +1,8 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common.IO;
+using Fallout.Kernel.IO;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasReports : IHasArtifacts
{
diff --git a/src/Fallout.Components/IHasSolution.cs b/src/Fallout.Application.Components/IHasSolution.cs
similarity index 55%
rename from src/Fallout.Components/IHasSolution.cs
rename to src/Fallout.Application.Components/IHasSolution.cs
index 8d5637319..013158d79 100644
--- a/src/Fallout.Components/IHasSolution.cs
+++ b/src/Fallout.Application.Components/IHasSolution.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Solutions;
+using Fallout.Application;
+using Fallout.Application.Solutions;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IHasSolution : IFalloutBuild
{
diff --git a/src/Fallout.Components/IHasTwitterCredentials.cs b/src/Fallout.Application.Components/IHasTwitterCredentials.cs
similarity index 85%
rename from src/Fallout.Components/IHasTwitterCredentials.cs
rename to src/Fallout.Application.Components/IHasTwitterCredentials.cs
index acf1314b7..109c704fd 100644
--- a/src/Fallout.Components/IHasTwitterCredentials.cs
+++ b/src/Fallout.Application.Components/IHasTwitterCredentials.cs
@@ -1,8 +1,8 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
+using Fallout.Application;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
[ParameterPrefix(Twitter)]
public interface IHasTwitterCredentials : IFalloutBuild
diff --git a/src/Fallout.Components/IPack.cs b/src/Fallout.Application.Components/IPack.cs
similarity index 81%
rename from src/Fallout.Components/IPack.cs
rename to src/Fallout.Application.Components/IPack.cs
index 9b3a66a4b..415773ae1 100644
--- a/src/Fallout.Components/IPack.cs
+++ b/src/Fallout.Application.Components/IPack.cs
@@ -1,14 +1,14 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IPack : ICompile, IHasArtifacts
{
diff --git a/src/Fallout.Components/IPublish.cs b/src/Fallout.Application.Components/IPublish.cs
similarity index 94%
rename from src/Fallout.Components/IPublish.cs
rename to src/Fallout.Application.Components/IPublish.cs
index 38a97d626..2d5ce881b 100644
--- a/src/Fallout.Components/IPublish.cs
+++ b/src/Fallout.Application.Components/IPublish.cs
@@ -3,15 +3,14 @@
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.IO;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
-
-namespace Fallout.Components;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
+
+namespace Fallout.Application.Components;
public interface IPublish : IPack, ITest
{
diff --git a/src/Fallout.Components/IReportCoverage.cs b/src/Fallout.Application.Components/IReportCoverage.cs
similarity index 81%
rename from src/Fallout.Components/IReportCoverage.cs
rename to src/Fallout.Application.Components/IReportCoverage.cs
index 5023fc79c..eb476c470 100644
--- a/src/Fallout.Components/IReportCoverage.cs
+++ b/src/Fallout.Application.Components/IReportCoverage.cs
@@ -1,18 +1,18 @@
-using System;
+using System;
using System.IO;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.CI.AzurePipelines;
-using Fallout.Common.IO;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.Codecov;
-using Fallout.Common.Tools.ReportGenerator;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.Codecov.CodecovTasks;
-using static Fallout.Common.Tools.ReportGenerator.ReportGeneratorTasks;
+using static Fallout.Application.Tools.Codecov.CodecovTasks;
+using static Fallout.Application.Tools.ReportGenerator.ReportGeneratorTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.Codecov;
+using Fallout.Application.Tools.ReportGenerator;
+using Fallout.Application.Tooling;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
+using Fallout.Kernel.Collections;
-namespace Fallout.Components;
+using Fallout.Application.CI;
+namespace Fallout.Application.Components;
public interface IReportCoverage : ITest, IHasReports, IHasGitRepository
{
@@ -72,7 +72,7 @@ public interface IReportCoverage : ITest, IHasReports, IHasGitRepository
void UploadCoverageData()
{
TestResultDirectory.GlobFiles("*.xml").ForEach(x =>
- AzurePipelines.Instance?.PublishCodeCoverage(
+ CiHost.AzurePipelines?.PublishCodeCoverage(
AzurePipelinesCodeCoverageToolType.Cobertura,
x,
CoverageReportDirectory));
diff --git a/src/Fallout.Components/IRestore.cs b/src/Fallout.Application.Components/IRestore.cs
similarity index 77%
rename from src/Fallout.Components/IRestore.cs
rename to src/Fallout.Application.Components/IRestore.cs
index 5819fe98a..41a93180a 100644
--- a/src/Fallout.Components/IRestore.cs
+++ b/src/Fallout.Application.Components/IRestore.cs
@@ -1,11 +1,11 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.DotNet;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
public interface IRestore : IHasSolution, IFalloutBuild
{
diff --git a/src/Fallout.Components/ISignPackages.cs b/src/Fallout.Application.Components/ISignPackages.cs
similarity index 93%
rename from src/Fallout.Components/ISignPackages.cs
rename to src/Fallout.Application.Components/ISignPackages.cs
index 2a3f8f003..8a88fa97c 100644
--- a/src/Fallout.Components/ISignPackages.cs
+++ b/src/Fallout.Application.Components/ISignPackages.cs
@@ -2,13 +2,14 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.CI.AppVeyor;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.SignPath.SignPathTasks;
+using static Fallout.Application.Tools.SignPath.SignPathTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.SignPath;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
-namespace Fallout.Components;
+using Fallout.Application.CI;
+namespace Fallout.Application.Components;
///
/// This component allows to easily sign NuGet packages with
@@ -62,7 +63,7 @@ public record SignPathSettings(
IEnumerable SignPathPackages { get; }
bool SignPathReplacePackages => true;
- private AppVeyor AppVeyor => AppVeyor.Instance;
+ private IAppVeyor AppVeyor => CiHost.AppVeyor;
Target SignPackages => _ => _
.TryDependsOn()
diff --git a/src/Fallout.Components/ITest.cs b/src/Fallout.Application.Components/ITest.cs
similarity index 82%
rename from src/Fallout.Components/ITest.cs
rename to src/Fallout.Application.Components/ITest.cs
index 537beb206..2c5ada7da 100644
--- a/src/Fallout.Components/ITest.cs
+++ b/src/Fallout.Application.Components/ITest.cs
@@ -1,21 +1,19 @@
-using System;
+using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
-using Fallout.Common;
-using Fallout.Common.CI.AzurePipelines;
-using Fallout.Common.CI.GitHubActions;
-using Fallout.Common.CI.TeamCity;
-using Fallout.Common.IO;
-using Fallout.Solutions;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools.Coverlet;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
-using static Fallout.Common.Tools.DotNet.DotNetTasks;
+using static Fallout.Application.Tools.DotNet.DotNetTasks;
+using Fallout.Application;
+using Fallout.Application.Tools.DotNet;
+using Fallout.Application.Tooling;
+using Fallout.Application.Tools.Coverlet;
+using Fallout.Kernel.IO;
+using Fallout.Kernel.Collections;
+using Fallout.Kernel;
-namespace Fallout.Components;
+using Fallout.Application.CI;
+using Fallout.Application.Solutions;
+namespace Fallout.Application.Components;
public interface ITest : ICompile, IHasArtifacts
{
@@ -50,9 +48,9 @@ public interface ITest : ICompile, IHasArtifacts
void ReportTestResults()
{
TestResultDirectory.GlobFiles("*.trx").ForEach(x =>
- AzurePipelines.Instance?.PublishTestResults(
+ CiHost.AzurePipelines?.PublishTestResults(
type: AzurePipelinesTestResultsType.VSTest,
- title: $"{Path.GetFileNameWithoutExtension(x)} ({AzurePipelines.Instance.StageDisplayName})",
+ title: $"{Path.GetFileNameWithoutExtension(x)} ({CiHost.AzurePipelines.StageDisplayName})",
files: new string[] { x }));
}
@@ -87,7 +85,7 @@ IEnumerable GetOutcomes(AbsolutePath file)
.EnableCollectCoverage()
.SetCoverletOutputFormat(CoverletOutputFormat.cobertura)
.SetExcludeByFile("*.Generated.cs")
- .When(TeamCity.Instance is not null, _ => _
+ .When(CiHost.TeamCity is not null, _ => _
.SetCoverletOutputFormat($"\\\"{CoverletOutputFormat.cobertura},{CoverletOutputFormat.teamcity}\\\""))
.When(IsServerBuild, _ => _
.EnableUseSourceLink()));
@@ -95,10 +93,10 @@ IEnumerable GetOutcomes(AbsolutePath file)
sealed Configure TestProjectSettingsBase => (_, v) => _
.SetProjectFile(v)
// https://github.com/Tyrrrz/GitHubActionsTestLogger
- .When(GitHubActions.Instance is not null && v.HasPackageReference("GitHubActionsTestLogger"), _ => _
+ .When(CiHost.GitHubActions is not null && v.HasPackageReference("GitHubActionsTestLogger"), _ => _
.AddLoggers("GitHubActions;report-warnings=false"))
// https://github.com/JetBrains/TeamCity.VSTest.TestAdapter
- .When(TeamCity.Instance is not null && v.HasPackageReference("TeamCity.VSTest.TestAdapter"), _ => _
+ .When(CiHost.TeamCity is not null && v.HasPackageReference("TeamCity.VSTest.TestAdapter"), _ => _
.AddLoggers("TeamCity")
// https://github.com/xunit/visualstudio.xunit/pull/108
.AddRunSetting("RunConfiguration.NoAutoReporters", bool.TrueString))
diff --git a/src/Fallout.Components/PublishTarget.cs b/src/Fallout.Application.Components/PublishTarget.cs
similarity index 98%
rename from src/Fallout.Components/PublishTarget.cs
rename to src/Fallout.Application.Components/PublishTarget.cs
index 94cacabd8..4e56d404d 100644
--- a/src/Fallout.Components/PublishTarget.cs
+++ b/src/Fallout.Application.Components/PublishTarget.cs
@@ -5,7 +5,7 @@
using System.Text;
using System.Text.RegularExpressions;
-namespace Fallout.Components;
+namespace Fallout.Application.Components;
///
/// A routable publish destination: a package feed plus the rules deciding which
diff --git a/src/Fallout.Application.Solutions/Fallout.Application.Solutions.csproj b/src/Fallout.Application.Solutions/Fallout.Application.Solutions.csproj
new file mode 100644
index 000000000..4e500af97
--- /dev/null
+++ b/src/Fallout.Application.Solutions/Fallout.Application.Solutions.csproj
@@ -0,0 +1,14 @@
+
+
+
+
+ netstandard2.0;net10.0
+ Fallout's public API (model + ports) for working with .NET solution files.
+
+
+
+
+
+
+
diff --git a/src/Fallout.Application.Solutions/Model.cs b/src/Fallout.Application.Solutions/Model.cs
new file mode 100644
index 000000000..e1fa7231a
--- /dev/null
+++ b/src/Fallout.Application.Solutions/Model.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Fallout.Kernel.IO;
+using Fallout.Kernel;
+
+namespace Fallout.Application.Solutions;
+
+public interface IProjectContainer
+{
+ IProjectContainer Parent { get; }
+ IReadOnlyCollection Projects { get; }
+ IReadOnlyCollection SolutionFolders { get; }
+}
+
+public static class ProjectContainerExtensions
+{
+ public static SolutionFolder GetSolutionFolder(this IProjectContainer container, string name)
+ {
+ return container.SolutionFolders.SingleOrDefault(x => name.Equals(x.Name, StringComparison.Ordinal));
+ }
+
+ ///
+ /// Gets a project by its name.
+ ///
+ public static Project GetProject(this IProjectContainer container, string name)
+ {
+ return container.Projects.SingleOrDefault(x => name.Equals(x.Name, StringComparison.Ordinal));
+ }
+}
+
+public class Solution : IProjectContainer, IAbsolutePathHolder
+{
+ private readonly List _allProjects = new();
+ private readonly List _allSolutionFolders = new();
+
+ ///
+ /// Constructs an (empty) solution. The project/folder tree is populated by the
+ /// reader (); the
+ /// is an opaque carrier for the underlying serializer
+ /// model so the solution can be saved back without the inner ring naming the
+ /// concrete (vendored) model type.
+ ///
+ protected internal Solution(AbsolutePath path = null, object handle = null)
+ {
+ Path = path;
+ Handle = handle;
+ }
+
+ /// The opaque serializer model this solution was read from (null if constructed in-memory).
+ internal object Handle { get; }
+
+ internal void AddProject(Project project) => _allProjects.Add(project);
+ internal void AddSolutionFolder(SolutionFolder folder) => _allSolutionFolders.Add(folder);
+
+ public AbsolutePath Path { get; set; }
+ public string Name => Path?.NameWithoutExtension;
+ public string FileName => Path?.Name;
+ public AbsolutePath Directory => Path?.Parent;
+
+ public IReadOnlyCollection AllProjects => _allProjects;
+ public IReadOnlyCollection AllSolutionFolders => _allSolutionFolders;
+
+ IProjectContainer IProjectContainer.Parent => null;
+ public IReadOnlyCollection Projects => AllProjects.Where(x => x.Parent == this).ToList();
+ public IReadOnlyCollection SolutionFolders => AllSolutionFolders.Where(x => x.Parent == this).ToList();
+
+ public static implicit operator string(Solution solution) => solution.Path;
+ public static implicit operator AbsolutePath(Solution solution) => solution.Path;
+
+ public IEnumerable GetAllProjects(string wildcardPattern)
+ {
+ wildcardPattern = $"^{wildcardPattern}$";
+ var regex = new Regex(wildcardPattern
+ .Replace(".", "\\.")
+ .Replace("*", ".*"));
+ return AllProjects.Where(x => regex.IsMatch(x.Name));
+ }
+
+ public void Save(AbsolutePath path = null)
+ {
+ Path = (path ?? Path).NotNull();
+ SolutionServices.Serializer.Save(this, Path);
+ }
+}
+
+public class SolutionItem
+{
+ private protected SolutionItem(string name, Solution solution)
+ {
+ Name = name;
+ Solution = solution;
+ }
+
+ public string Name { get; }
+
+ public Solution Solution { get; }
+ public IProjectContainer Parent { get; internal set; }
+
+ public override string ToString() => Name;
+}
+
+public class SolutionFolder : SolutionItem, IProjectContainer
+{
+ internal SolutionFolder(string name, Solution solution)
+ : base(name, solution)
+ {
+ }
+
+ // Vestigial: strongly-typed folder subclasses (generated, in consumer assemblies) are
+ // reached via Unsafe.As and never actually constructed, but their declarations still
+ // need an accessible (cross-assembly => protected) base ctor to compile.
+ protected SolutionFolder()
+ : base(name: null, solution: null)
+ {
+ }
+
+ public IReadOnlyCollection Projects => Solution.AllProjects.Where(x => x.Parent == this).ToList();
+ public IReadOnlyCollection SolutionFolders => Solution.AllSolutionFolders.Where(x => x.Parent == this).ToList();
+}
+
+public class Project : SolutionItem, IAbsolutePathHolder
+{
+ internal Project(string name, string relativePath, Solution solution)
+ : base(name, solution)
+ {
+ RelativePath = relativePath;
+ }
+
+ public string RelativePath { get; }
+ public AbsolutePath Path => Solution.Directory.NotNull() / RelativePath;
+ public string FileName => System.IO.Path.GetFileName(RelativePath);
+ public AbsolutePath Directory => Path?.Parent;
+
+ public static implicit operator string(Project project) => project.Path;
+ public static implicit operator AbsolutePath(Project project) => project.Path;
+}
diff --git a/src/Fallout.Application.Solutions/ProjectQueryExtensions.cs b/src/Fallout.Application.Solutions/ProjectQueryExtensions.cs
new file mode 100644
index 000000000..f09b98be7
--- /dev/null
+++ b/src/Fallout.Application.Solutions/ProjectQueryExtensions.cs
@@ -0,0 +1,16 @@
+using Fallout.Kernel.IO;
+
+namespace Fallout.Application.Solutions;
+
+// Application-ring conveniences over a Project that need impure MSBuild evaluation. They route through the
+// IProjectEditor port (implemented in Fallout.ProjectModel) so the inner ring stays free of Microsoft.Build.
+// The richer query surface (GetTargetFrameworks/GetItems/GetProperty/...) lives on the Infrastructure-side
+// ProjectExtensions and is for consumers/tests that can reference the outer ring directly.
+public static class ProjectQueryExtensions
+{
+ /// Indicates whether the project references the given package ID (a PackageReference item).
+ public static bool HasPackageReference(this Project project, string packageId)
+ {
+ return SolutionServices.Projects.HasPackageReference(project.Path, packageId);
+ }
+}
diff --git a/src/Fallout.Application.Solutions/SolutionModelExtensions.cs b/src/Fallout.Application.Solutions/SolutionModelExtensions.cs
new file mode 100644
index 000000000..b2a4a0dad
--- /dev/null
+++ b/src/Fallout.Application.Solutions/SolutionModelExtensions.cs
@@ -0,0 +1,17 @@
+using Fallout.Kernel.IO;
+
+namespace Fallout.Application.Solutions;
+
+public static class SolutionModelExtensions
+{
+ public static Solution ReadSolution(this AbsolutePath path)
+ {
+ return SolutionServices.Serializer.Open(path);
+ }
+
+ public static Solution ReadSolution(this AbsolutePath path)
+ where T : Solution
+ {
+ return SolutionServices.Serializer.Open(path);
+ }
+}
diff --git a/src/Fallout.Application.Solutions/SolutionServices.cs b/src/Fallout.Application.Solutions/SolutionServices.cs
new file mode 100644
index 000000000..70729c204
--- /dev/null
+++ b/src/Fallout.Application.Solutions/SolutionServices.cs
@@ -0,0 +1,55 @@
+using Fallout.Kernel.IO;
+
+namespace Fallout.Application.Solutions;
+
+// Ports for the impure solution/project I/O (ADR-0006, onion realignment step 5c). The Application ring
+// (the Solution/Project model, [Solution] injection, build orchestration) depends only on these
+// abstractions; the concrete adapters — the vendored .sln/.slnx serializers and the MSBuild project
+// evaluator — live behind them and register into SolutionServices via module initializers. This is the
+// inversion that keeps the model free of any concrete persistence/MSBuild dependency (the format-specific
+// implementations are the "outside" of the onion; the abstract concept is here, inside).
+
+///
+/// Reads/writes a across the supported file formats (legacy .sln and the
+/// XML .slnx). The concrete, format-specific serializers live in the Infrastructure adapter.
+///
+public interface ISolutionSerializer
+{
+ /// Reads a solution file into the Fallout model.
+ Solution Open(AbsolutePath path);
+
+ /// Reads a solution file into a strongly-typed solution subclass.
+ T Open(AbsolutePath path) where T : Solution;
+
+ /// Writes a previously-read solution back to .
+ void Save(Solution solution, AbsolutePath path);
+}
+
+///
+/// Reads/edits MSBuild project files (property evaluation + mutation). The concrete implementation lives in
+/// Fallout.ProjectModel (the Microsoft.Build evaluator) — the impure "outside" of the onion.
+///
+public interface IProjectEditor
+{
+ /// Evaluated value of the first of that is set, or null.
+ string GetProperty(AbsolutePath projectFile, params string[] propertyNames);
+
+ /// Sets to on the project and saves it.
+ void SetProperty(AbsolutePath projectFile, string name, string value);
+
+ /// Indicates whether the project references the given package ID (a PackageReference item).
+ bool HasPackageReference(AbsolutePath projectFile, string packageId);
+}
+
+///
+/// Service locator holding the registered Infrastructure adapters for the solution/project ports. The
+/// solution serializer is registered by a module initializer co-hosted in this assembly (so it is always
+/// set once the model assembly loads). The project editor is registered from Fallout.ProjectModel when
+/// that assembly loads (the CLI composition root / MSBuild bootstrapping pulls it in). Tests may swap
+/// implementations directly.
+///
+public static class SolutionServices
+{
+ public static ISolutionSerializer Serializer { get; set; }
+ public static IProjectEditor Projects { get; set; }
+}
diff --git a/src/Fallout.Tooling/ArgumentStringHandler.cs b/src/Fallout.Application.Tooling/ArgumentStringHandler.cs
similarity index 95%
rename from src/Fallout.Tooling/ArgumentStringHandler.cs
rename to src/Fallout.Application.Tooling/ArgumentStringHandler.cs
index db3542d21..f4a91f1c5 100644
--- a/src/Fallout.Tooling/ArgumentStringHandler.cs
+++ b/src/Fallout.Application.Tooling/ArgumentStringHandler.cs
@@ -1,13 +1,13 @@
-#if NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
-using Fallout.Common.IO;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
+using Fallout.Kernel.IO;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
[InterpolatedStringHandler]
public ref struct ArgumentStringHandler
diff --git a/src/Fallout.Tooling/Configure.cs b/src/Fallout.Application.Tooling/Configure.cs
similarity index 95%
rename from src/Fallout.Tooling/Configure.cs
rename to src/Fallout.Application.Tooling/Configure.cs
index 15014593d..38ec3febc 100644
--- a/src/Fallout.Tooling/Configure.cs
+++ b/src/Fallout.Application.Tooling/Configure.cs
@@ -2,9 +2,9 @@
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
-using Fallout.Common.Utilities.Collections;
+using Fallout.Kernel.Collections;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public delegate T Configure(T options);
@@ -90,7 +90,7 @@ private static IReadOnlyCollection Invoke(
finally
{
invocations
- .Where(x => x.Options.ProcessOutputLogging ?? ProcessTasks.DefaultLogOutput)
+ .Where(x => x.Options.ProcessOutputLogging ?? ToolingServices.Process.DefaultLogOutput)
.SelectMany(x =>
{
var (_, logger, result, exception) = x;
diff --git a/src/Fallout.Tooling/DelegateHelper.cs b/src/Fallout.Application.Tooling/DelegateHelper.cs
similarity index 97%
rename from src/Fallout.Tooling/DelegateHelper.cs
rename to src/Fallout.Application.Tooling/DelegateHelper.cs
index 5325f38b7..7d1b6fa87 100644
--- a/src/Fallout.Tooling/DelegateHelper.cs
+++ b/src/Fallout.Application.Tooling/DelegateHelper.cs
@@ -1,10 +1,10 @@
-using System;
+using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public static class DelegateHelper
{
diff --git a/src/Fallout.Tooling/Enumeration.cs b/src/Fallout.Application.Tooling/Enumeration.cs
similarity index 97%
rename from src/Fallout.Tooling/Enumeration.cs
rename to src/Fallout.Application.Tooling/Enumeration.cs
index 1bc9711bb..c4bd3847a 100644
--- a/src/Fallout.Tooling/Enumeration.cs
+++ b/src/Fallout.Application.Tooling/Enumeration.cs
@@ -4,9 +4,9 @@
using System.Globalization;
using System.Linq;
using System.Reflection;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
[AttributeUsage(AttributeTargets.Field)]
public class EnumValueAttribute : Attribute
diff --git a/src/Fallout.Tooling/EnumerationJsonConverter.cs b/src/Fallout.Application.Tooling/EnumerationJsonConverter.cs
similarity index 97%
rename from src/Fallout.Tooling/EnumerationJsonConverter.cs
rename to src/Fallout.Application.Tooling/EnumerationJsonConverter.cs
index 01ec7301a..3ff322b59 100644
--- a/src/Fallout.Tooling/EnumerationJsonConverter.cs
+++ b/src/Fallout.Application.Tooling/EnumerationJsonConverter.cs
@@ -3,9 +3,9 @@
using System.Globalization;
using System.Text.Json;
using System.Text.Json.Serialization;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
///
/// Bridges subclasses across the System.Text.Json boundary.
diff --git a/src/Fallout.Application.Tooling/Fallout.Application.Tooling.csproj b/src/Fallout.Application.Tooling/Fallout.Application.Tooling.csproj
new file mode 100644
index 000000000..1d172f446
--- /dev/null
+++ b/src/Fallout.Application.Tooling/Fallout.Application.Tooling.csproj
@@ -0,0 +1,19 @@
+
+
+
+
+ netstandard2.0;net10.0
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Fallout.Tooling/IProcess.cs b/src/Fallout.Application.Tooling/IProcess.cs
similarity index 96%
rename from src/Fallout.Tooling/IProcess.cs
rename to src/Fallout.Application.Tooling/IProcess.cs
index 09e7230c6..71471a765 100644
--- a/src/Fallout.Tooling/IProcess.cs
+++ b/src/Fallout.Application.Tooling/IProcess.cs
@@ -1,9 +1,9 @@
-using System;
+using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
///
/// Abstraction for .
diff --git a/src/Fallout.Application.Tooling/IProcessRunner.cs b/src/Fallout.Application.Tooling/IProcessRunner.cs
new file mode 100644
index 000000000..458871d3b
--- /dev/null
+++ b/src/Fallout.Application.Tooling/IProcessRunner.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Diagnostics;
+
+namespace Fallout.Application.Tooling;
+
+///
+/// The process-execution port (ADR-0006 step 3). Abstracts the single impure step of running a tool —
+/// spawning an OS process — so the tooling vocabulary (, the generated
+/// wrappers) stays pure and side-effect-free, and builds become unit-testable by swapping in a fake
+/// runner via ProcessTasks.Runner. The default adapter is SystemProcessRunner (both in the
+/// outer Fallout.Infrastructure.Tooling ring).
+///
+public interface IProcessRunner
+{
+ IProcess Start(ProcessStartInfo startInfo, int? timeout, Action logger, Func outputFilter);
+}
diff --git a/src/Fallout.Tooling/ObjectFromFieldConverter.cs b/src/Fallout.Application.Tooling/ObjectFromFieldConverter.cs
similarity index 96%
rename from src/Fallout.Tooling/ObjectFromFieldConverter.cs
rename to src/Fallout.Application.Tooling/ObjectFromFieldConverter.cs
index bd34b33f7..351989ac1 100644
--- a/src/Fallout.Tooling/ObjectFromFieldConverter.cs
+++ b/src/Fallout.Application.Tooling/ObjectFromFieldConverter.cs
@@ -3,9 +3,9 @@
using System.Reflection;
using System.Text.Json;
using System.Text.Json.Serialization;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
///
/// Redirects (de)serialization of a type through one of its non-public fields.
diff --git a/src/Fallout.Tooling/Options.Apply.cs b/src/Fallout.Application.Tooling/Options.Apply.cs
similarity index 95%
rename from src/Fallout.Tooling/Options.Apply.cs
rename to src/Fallout.Application.Tooling/Options.Apply.cs
index a722484a7..9230fbec7 100644
--- a/src/Fallout.Tooling/Options.Apply.cs
+++ b/src/Fallout.Application.Tooling/Options.Apply.cs
@@ -1,6 +1,6 @@
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
partial class OptionsExtensions
{
diff --git a/src/Fallout.Tooling/Options.Combinatorial.cs b/src/Fallout.Application.Tooling/Options.Combinatorial.cs
similarity index 98%
rename from src/Fallout.Tooling/Options.Combinatorial.cs
rename to src/Fallout.Application.Tooling/Options.Combinatorial.cs
index c432334c9..a198aa16f 100644
--- a/src/Fallout.Tooling/Options.Combinatorial.cs
+++ b/src/Fallout.Application.Tooling/Options.Combinatorial.cs
@@ -2,7 +2,7 @@
using System.Collections.Generic;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
partial class OptionsExtensions
{
diff --git a/src/Fallout.Tooling/Options.Modify.cs b/src/Fallout.Application.Tooling/Options.Modify.cs
similarity index 96%
rename from src/Fallout.Tooling/Options.Modify.cs
rename to src/Fallout.Application.Tooling/Options.Modify.cs
index f07079db2..e17e4e85b 100644
--- a/src/Fallout.Tooling/Options.Modify.cs
+++ b/src/Fallout.Application.Tooling/Options.Modify.cs
@@ -1,7 +1,7 @@
using System;
using System.Text.Json;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public static partial class OptionsExtensions
{
diff --git a/src/Fallout.Tooling/Options.When.cs b/src/Fallout.Application.Tooling/Options.When.cs
similarity index 93%
rename from src/Fallout.Tooling/Options.When.cs
rename to src/Fallout.Application.Tooling/Options.When.cs
index c5efce54a..d6891e878 100644
--- a/src/Fallout.Tooling/Options.When.cs
+++ b/src/Fallout.Application.Tooling/Options.When.cs
@@ -1,7 +1,7 @@
using System;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
partial class OptionsExtensions
{
diff --git a/src/Fallout.Tooling/Options.cs b/src/Fallout.Application.Tooling/Options.cs
similarity index 98%
rename from src/Fallout.Tooling/Options.cs
rename to src/Fallout.Application.Tooling/Options.cs
index 7976f1b65..116b1a035 100644
--- a/src/Fallout.Tooling/Options.cs
+++ b/src/Fallout.Application.Tooling/Options.cs
@@ -7,10 +7,10 @@
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
+using Fallout.Kernel;
+using Fallout.Kernel.Collections;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public interface IOptions
{
diff --git a/src/Fallout.Tooling/Output.cs b/src/Fallout.Application.Tooling/Output.cs
similarity index 64%
rename from src/Fallout.Tooling/Output.cs
rename to src/Fallout.Application.Tooling/Output.cs
index 08d165a05..92fd6ff2d 100644
--- a/src/Fallout.Tooling/Output.cs
+++ b/src/Fallout.Application.Tooling/Output.cs
@@ -1,7 +1,7 @@
-using System;
+using System;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public struct Output
{
diff --git a/src/Fallout.Tooling/OutputType.cs b/src/Fallout.Application.Tooling/OutputType.cs
similarity index 55%
rename from src/Fallout.Tooling/OutputType.cs
rename to src/Fallout.Application.Tooling/OutputType.cs
index 034f48fde..a63a5fcb1 100644
--- a/src/Fallout.Tooling/OutputType.cs
+++ b/src/Fallout.Application.Tooling/OutputType.cs
@@ -1,7 +1,7 @@
-using System;
+using System;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
public enum OutputType
{
diff --git a/src/Fallout.Tooling/ProcessException.cs b/src/Fallout.Application.Tooling/ProcessException.cs
similarity index 93%
rename from src/Fallout.Tooling/ProcessException.cs
rename to src/Fallout.Application.Tooling/ProcessException.cs
index aaa8a9c1f..96a33823f 100644
--- a/src/Fallout.Tooling/ProcessException.cs
+++ b/src/Fallout.Application.Tooling/ProcessException.cs
@@ -3,12 +3,12 @@
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
-using Fallout.Common.Utilities;
-using Fallout.Common.Utilities.Collections;
using Serilog;
using Serilog.Events;
+using Fallout.Kernel;
+using Fallout.Kernel.Collections;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
[Serializable]
public class ProcessException : Exception
diff --git a/src/Fallout.Tooling/ProcessExtensions.cs b/src/Fallout.Application.Tooling/ProcessExtensions.cs
similarity index 95%
rename from src/Fallout.Tooling/ProcessExtensions.cs
rename to src/Fallout.Application.Tooling/ProcessExtensions.cs
index 40be83ec9..de9f5065d 100644
--- a/src/Fallout.Tooling/ProcessExtensions.cs
+++ b/src/Fallout.Application.Tooling/ProcessExtensions.cs
@@ -3,9 +3,9 @@
using System.Linq;
using System.Text.Json;
using System.Text.Json.Nodes;
-using Fallout.Common.Utilities;
+using Fallout.Kernel;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
[DebuggerStepThrough]
[DebuggerNonUserCode]
diff --git a/src/Fallout.Tooling/Tool.cs b/src/Fallout.Application.Tooling/Tool.cs
similarity index 95%
rename from src/Fallout.Tooling/Tool.cs
rename to src/Fallout.Application.Tooling/Tool.cs
index 83d70f870..327f6e053 100644
--- a/src/Fallout.Tooling/Tool.cs
+++ b/src/Fallout.Application.Tooling/Tool.cs
@@ -2,7 +2,7 @@
using System.Collections.Generic;
using System.Linq;
-namespace Fallout.Common.Tooling;
+namespace Fallout.Application.Tooling;
#if NET6_0_OR_GREATER
public delegate IReadOnlyCollection
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -28,13 +24,13 @@ public partial class CodecovTasks : ToolTasks, IRequireNuGetPackage
/// Code coverage is a measurement used to express which lines of code were executed by a test suite. We use three primary terms to describe each line executed.
- hit - indicates that the source code was executed by the test suite.
- partial - indicates that the source code was not fully executed by the test suite; there are remaining branches that were not executed.
- miss - indicates that the source code was not executed by the test suite.
Coverage is the ratio of hits / (sum of hit + partial + miss). A code base that has 5 lines executed by tests out of 12 total lines will receive a coverage ratio of 41% (rounding down).Phrased simply, code coverage provides a visual measurement of what source code is being executed by a test suite. This information indicates to the software developer where they should write new tests in an effort to achieve higher coverage.Testing source code helps to prevent bugs and syntax errors by executing each line with a known variable and cross-checking it with an expected output.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --branch via
- --build via
- --disable-network via
- --dump via
- --env via
- --feature via
- --file via
- --flag via
- --name via
- --no-color via
- --pr via
- --required via
- --root via
- --sha via
- --slug via
- --tag via
- --token via
- --url via
- --verbose via
public static IReadOnlyCollection Codecov(CodecovSettings options = null) => new CodecovTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection Codecov(Configure configurator) => new CodecovTasks().Run(configurator.Invoke(new CodecovSettings()));
- ///
+ ///
public static IEnumerable<(CodecovSettings Settings, IReadOnlyCollection Output)> Codecov(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(Codecov, degreeOfParallelism, completeOnFailure);
}
#region CodecovSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(CodecovTasks), Command = nameof(CodecovTasks.Codecov))]
public partial class CodecovSettings : ToolOptions
@@ -82,7 +78,7 @@ public partial class CodecovSettings : ToolOptions
}
#endregion
#region CodecovSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class CodecovSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/Codecov/Codecov.json b/src/Fallout.Application.Tools/Codecov/Codecov.json
similarity index 100%
rename from src/Fallout.Common/Tools/Codecov/Codecov.json
rename to src/Fallout.Application.Tools/Codecov/Codecov.json
diff --git a/src/Fallout.Common/Tools/Codecov/CodecovTasks.cs b/src/Fallout.Application.Tools/Codecov/CodecovTasks.cs
similarity index 72%
rename from src/Fallout.Common/Tools/Codecov/CodecovTasks.cs
rename to src/Fallout.Application.Tools/Codecov/CodecovTasks.cs
index 8cbcccf33..51dece938 100644
--- a/src/Fallout.Common/Tools/Codecov/CodecovTasks.cs
+++ b/src/Fallout.Application.Tools/Codecov/CodecovTasks.cs
@@ -1,13 +1,14 @@
-using System;
-using Fallout.Common.Tooling;
+using System;
+using Fallout.Application.Tooling;
+using Fallout.Kernel;
-namespace Fallout.Common.Tools.Codecov;
+namespace Fallout.Application.Tools.Codecov;
partial class CodecovTasks
{
protected override string GetToolPath(ToolOptions options = null)
{
- return NuGetToolPathResolver.GetPackageExecutable(
+ return ToolingServices.ToolPaths.GetPackageExecutable(
packageId: PackageId,
packageExecutable: EnvironmentInfo.Platform switch
{
diff --git a/src/Fallout.Common/Tools/CorFlags/CorFlags.Generated.cs b/src/Fallout.Application.Tools/CorFlags/CorFlags.Generated.cs
similarity index 95%
rename from src/Fallout.Common/Tools/CorFlags/CorFlags.Generated.cs
rename to src/Fallout.Application.Tools/CorFlags/CorFlags.Generated.cs
index e640f3b08..3cd7078af 100644
--- a/src/Fallout.Common/Tools/CorFlags/CorFlags.Generated.cs
+++ b/src/Fallout.Application.Tools/CorFlags/CorFlags.Generated.cs
@@ -1,9 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/CorFlags/CorFlags.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -13,8 +7,9 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.CorFlags;
+namespace Fallout.Application.Tools.CorFlags;
/// The CorFlags Conversion tool allows you to configure the CorFlags section of the header of a portable executable image.
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -28,13 +23,13 @@ public partial class CorFlagsTasks : ToolTasks, IRequirePathTool
/// The CorFlags Conversion tool allows you to configure the CorFlags section of the header of a portable executable image.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <assembly> via
- -32BIT via
- -32BITPREF via
- -Force via
- -ILONLY via
- -nologo via
- -RevertCLRHeader via
- -UpgradeCLRHeader via
public static IReadOnlyCollection CorFlags(CorFlagsSettings options = null) => new CorFlagsTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection CorFlags(Configure configurator) => new CorFlagsTasks().Run(configurator.Invoke(new CorFlagsSettings()));
- ///
+ ///
public static IEnumerable<(CorFlagsSettings Settings, IReadOnlyCollection Output)> CorFlags(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(CorFlags, degreeOfParallelism, completeOnFailure);
}
#region CorFlagsSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(CorFlagsTasks), Command = nameof(CorFlagsTasks.CorFlags))]
public partial class CorFlagsSettings : ToolOptions
@@ -58,7 +53,7 @@ public partial class CorFlagsSettings : ToolOptions
}
#endregion
#region CorFlagsSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class CorFlagsSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/CorFlags/CorFlags.json b/src/Fallout.Application.Tools/CorFlags/CorFlags.json
similarity index 100%
rename from src/Fallout.Common/Tools/CorFlags/CorFlags.json
rename to src/Fallout.Application.Tools/CorFlags/CorFlags.json
diff --git a/src/Fallout.Common/Tools/CorFlags/CorFlagsSettings.cs b/src/Fallout.Application.Tools/CorFlags/CorFlagsSettings.cs
similarity index 80%
rename from src/Fallout.Common/Tools/CorFlags/CorFlagsSettings.cs
rename to src/Fallout.Application.Tools/CorFlags/CorFlagsSettings.cs
index cbf870749..6ec2148f7 100644
--- a/src/Fallout.Common/Tools/CorFlags/CorFlagsSettings.cs
+++ b/src/Fallout.Application.Tools/CorFlags/CorFlagsSettings.cs
@@ -1,7 +1,7 @@
-using System;
+using System;
using System.Reflection;
-namespace Fallout.Common.Tools.CorFlags;
+namespace Fallout.Application.Tools.CorFlags;
partial class CorFlagsSettings
{
diff --git a/src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.Generated.cs b/src/Fallout.Application.Tools/CoverallsNet/CoverallsNet.Generated.cs
similarity index 97%
rename from src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.Generated.cs
rename to src/Fallout.Application.Tools/CoverallsNet/CoverallsNet.Generated.cs
index 51362c4a2..ccea9c0b7 100644
--- a/src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.Generated.cs
+++ b/src/Fallout.Application.Tools/CoverallsNet/CoverallsNet.Generated.cs
@@ -1,9 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -13,8 +7,10 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.CoverallsNet;
+namespace Fallout.Application.Tools.CoverallsNet;
/// Coveralls uploader for .Net Code coverage of your C# source code. Should work with any code files that get reported with the supported coverage tools, but the primary focus is CSharp.
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -29,13 +25,13 @@ public partial class CoverallsNetTasks : ToolTasks, IRequireNuGetPackage
/// Coveralls uploader for .Net Code coverage of your C# source code. Should work with any code files that get reported with the supported coverage tools, but the primary focus is CSharp.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --basePath via
- --commitAuthor via
- --commitBranch via
- --commitEmail via
- --commitId via
- --commitMessage via
- --dryrun via
- --dynamiccodecoverage via
- --exportcodecoverage via
- --input via
- --jobId via
- --monocov via
- --opencover via
- --output via
- --pullRequest via
- --repoToken via
- --repoTokenVariable via
- --serviceName via
- --useRelativePaths via
public static IReadOnlyCollection CoverallsNet(CoverallsNetSettings options = null) => new CoverallsNetTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection CoverallsNet(Configure configurator) => new CoverallsNetTasks().Run(configurator.Invoke(new CoverallsNetSettings()));
- ///
+ ///
public static IEnumerable<(CoverallsNetSettings Settings, IReadOnlyCollection Output)> CoverallsNet(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(CoverallsNet, degreeOfParallelism, completeOnFailure);
}
#region CoverallsNetSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(CoverallsNetTasks), Command = nameof(CoverallsNetTasks.CoverallsNet))]
public partial class CoverallsNetSettings : ToolOptions
@@ -81,7 +77,7 @@ public partial class CoverallsNetSettings : ToolOptions
}
#endregion
#region CoverallsNetSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class CoverallsNetSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.json b/src/Fallout.Application.Tools/CoverallsNet/CoverallsNet.json
similarity index 100%
rename from src/Fallout.Common/Tools/CoverallsNet/CoverallsNet.json
rename to src/Fallout.Application.Tools/CoverallsNet/CoverallsNet.json
diff --git a/src/Fallout.Common/Tools/Coverlet/Coverlet.Generated.cs b/src/Fallout.Application.Tools/Coverlet/Coverlet.Generated.cs
similarity index 97%
rename from src/Fallout.Common/Tools/Coverlet/Coverlet.Generated.cs
rename to src/Fallout.Application.Tools/Coverlet/Coverlet.Generated.cs
index 317aeca9e..5424670e1 100644
--- a/src/Fallout.Common/Tools/Coverlet/Coverlet.Generated.cs
+++ b/src/Fallout.Application.Tools/Coverlet/Coverlet.Generated.cs
@@ -1,10 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/Coverlet/Coverlet.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Tools.DotNet;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -14,8 +7,10 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application.Tooling;
+using Fallout.Application.Tools.DotNet;
-namespace Fallout.Common.Tools.Coverlet;
+namespace Fallout.Application.Tools.Coverlet;
/// Coverlet is a cross platform code coverage library for .NET Core, with support for line, branch and method coverage.The dotnet test command is used to execute unit tests in a given project. Unit tests are console application projects that have dependencies on the unit test framework (for example, MSTest, NUnit, or xUnit) and the dotnet test runner for the unit testing framework. These are packaged as NuGet packages and are restored as ordinary dependencies for the project.
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -30,13 +25,13 @@ public partial class CoverletTasks : ToolTasks, IRequireNuGetPackage
/// Coverlet is a cross platform code coverage library for .NET Core, with support for line, branch and method coverage.The dotnet test command is used to execute unit tests in a given project. Unit tests are console application projects that have dependencies on the unit test framework (for example, MSTest, NUnit, or xUnit) and the dotnet test runner for the unit testing framework. These are packaged as NuGet packages and are restored as ordinary dependencies for the project.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <assembly> via
- --exclude via
- --exclude-by-file via
- --format via
- --include via
- --merge-with via
- --output via
- --target via
- --targetargs via
- --threshold via
- --threshold-type via
- --version via
public static IReadOnlyCollection Coverlet(CoverletSettings options = null) => new CoverletTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection Coverlet(Configure configurator) => new CoverletTasks().Run(configurator.Invoke(new CoverletSettings()));
- ///
+ ///
public static IEnumerable<(CoverletSettings Settings, IReadOnlyCollection Output)> Coverlet(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(Coverlet, degreeOfParallelism, completeOnFailure);
}
#region CoverletSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(CoverletTasks), Command = nameof(CoverletTasks.Coverlet))]
public partial class CoverletSettings : ToolOptions
@@ -68,7 +63,7 @@ public partial class CoverletSettings : ToolOptions
}
#endregion
#region CoverletSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class CoverletSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/Coverlet/Coverlet.json b/src/Fallout.Application.Tools/Coverlet/Coverlet.json
similarity index 100%
rename from src/Fallout.Common/Tools/Coverlet/Coverlet.json
rename to src/Fallout.Application.Tools/Coverlet/Coverlet.json
diff --git a/src/Fallout.Common/Tools/Coverlet/CoverletSettingsExtensions.cs b/src/Fallout.Application.Tools/Coverlet/CoverletSettingsExtensions.cs
similarity index 90%
rename from src/Fallout.Common/Tools/Coverlet/CoverletSettingsExtensions.cs
rename to src/Fallout.Application.Tools/Coverlet/CoverletSettingsExtensions.cs
index d37e3dfb3..0acd04d30 100644
--- a/src/Fallout.Common/Tools/Coverlet/CoverletSettingsExtensions.cs
+++ b/src/Fallout.Application.Tools/Coverlet/CoverletSettingsExtensions.cs
@@ -1,8 +1,8 @@
-using System;
+using System;
using System.Linq;
-using Fallout.Common.Tooling;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.Coverlet;
+namespace Fallout.Application.Tools.Coverlet;
public static partial class CoverletSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/Discord/Discord.Generated.cs b/src/Fallout.Application.Tools/Discord/Discord.Generated.cs
similarity index 99%
rename from src/Fallout.Common/Tools/Discord/Discord.Generated.cs
rename to src/Fallout.Application.Tools/Discord/Discord.Generated.cs
index cd09ab349..75481eba9 100644
--- a/src/Fallout.Common/Tools/Discord/Discord.Generated.cs
+++ b/src/Fallout.Application.Tools/Discord/Discord.Generated.cs
@@ -1,9 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/Discord/Discord.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -13,8 +7,9 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.Discord;
+namespace Fallout.Application.Tools.Discord;
#region DiscordMessage
/// Used within .
diff --git a/src/Fallout.Common/Tools/Discord/Discord.json b/src/Fallout.Application.Tools/Discord/Discord.json
similarity index 100%
rename from src/Fallout.Common/Tools/Discord/Discord.json
rename to src/Fallout.Application.Tools/Discord/Discord.json
diff --git a/src/Fallout.Common/Tools/Discord/DiscordTasks.cs b/src/Fallout.Application.Tools/Discord/DiscordTasks.cs
similarity index 86%
rename from src/Fallout.Common/Tools/Discord/DiscordTasks.cs
rename to src/Fallout.Application.Tools/Discord/DiscordTasks.cs
index 398d2cc39..314126812 100644
--- a/src/Fallout.Common/Tools/Discord/DiscordTasks.cs
+++ b/src/Fallout.Application.Tools/Discord/DiscordTasks.cs
@@ -1,9 +1,9 @@
using System.Net.Http;
using System.Threading.Tasks;
-using Fallout.Common.Tooling;
-using Fallout.Common.Utilities.Net;
+using Fallout.Application.Tooling;
+using Fallout.Kernel.Net;
-namespace Fallout.Common.Tools.Discord;
+namespace Fallout.Application.Tools.Discord;
public static class DiscordTasks
{
diff --git a/src/Fallout.Common/Tools/DocFX/DocFX.Generated.cs b/src/Fallout.Application.Tools/DocFX/DocFX.Generated.cs
similarity index 98%
rename from src/Fallout.Common/Tools/DocFX/DocFX.Generated.cs
rename to src/Fallout.Application.Tools/DocFX/DocFX.Generated.cs
index 96ed4968c..6f132e3f7 100644
--- a/src/Fallout.Common/Tools/DocFX/DocFX.Generated.cs
+++ b/src/Fallout.Application.Tools/DocFX/DocFX.Generated.cs
@@ -1,9 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/DocFX/DocFX.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -13,8 +7,9 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.DocFX;
+namespace Fallout.Application.Tools.DocFX;
/// DocFX is an API documentation generator for .NET, and currently it supports C# and VB. It generates API reference documentation from triple-slash comments in your source code. It also allows you to use Markdown files to create additional topics such as tutorials and how-tos, and to customize the generated reference documentation. DocFX builds a static HTML website from your source code and Markdown files, which can be easily hosted on any web servers (for example, github.io). Also, DocFX provides you the flexibility to customize the layout and style of your website through templates. If you are interested in creating your own website with your own styles, you can follow how to create custom template to create custom templates.
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -29,76 +24,76 @@ public partial class DocFXTasks : ToolTasks, IRequireNuGetPackage
/// Generate client-only website combining API in YAML files and conceptual files.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <configFile> via
- --changesFile via
- --cleanupCacheHistory via
- --content via
- --correlationId via
- --debug via
- --debugOutput via
- --disableGitFeatures via
- --dryRun via
- --exportRawModel via
- --exportViewModel via
- --falName via
- --fileMetadataFile via
- --fileMetadataFiles via
- --force via
- --forcePostProcess via
- --globalMetadata via
- --globalMetadataFile via
- --globalMetadataFiles via
- --help via
- --hostname via
- --intermediateFolder via
- --keepFileLink via
- --log via
- --logLevel via
- --lruSize via
- --markdownEngineName via
- --markdownEngineProperties via
- --maxParallelism via
- --noLangKeyword via
- --output via
- --overwrite via
- --port via
- --postProcessors via
- --rawModelOutputFolder via
- --repositoryRoot via
- --resource via
- --schemaLicense via
- --serve via
- --template via
- --theme via
- --viewModelOutputFolder via
- --warningsAsErrors via
- --xref via
public static IReadOnlyCollection DocFXBuild(DocFXBuildSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXBuild(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXBuildSettings()));
- ///
+ ///
public static IEnumerable<(DocFXBuildSettings Settings, IReadOnlyCollection Output)> DocFXBuild(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXBuild, degreeOfParallelism, completeOnFailure);
/// Export dependency file.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <dependencyFile> via
- --help via
- --intermediateFolder via
- --version via
public static IReadOnlyCollection DocFXDependency(DocFXDependencySettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXDependency(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXDependencySettings()));
- ///
+ ///
public static IEnumerable<(DocFXDependencySettings Settings, IReadOnlyCollection Output)> DocFXDependency(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXDependency, degreeOfParallelism, completeOnFailure);
/// Download remote xref map file and create an xref archive in local.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <archiveFile> via
- --help via
- --xref via
public static IReadOnlyCollection DocFXDownload(DocFXDownloadSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXDownload(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXDownloadSettings()));
- ///
+ ///
public static IEnumerable<(DocFXDownloadSettings Settings, IReadOnlyCollection Output)> DocFXDownload(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXDownload, degreeOfParallelism, completeOnFailure);
/// Get an overall guide for the command and sub-commands.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
public static IReadOnlyCollection DocFXHelp(DocFXHelpSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXHelp(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXHelpSettings()));
- ///
+ ///
public static IEnumerable<(DocFXHelpSettings Settings, IReadOnlyCollection Output)> DocFXHelp(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXHelp, degreeOfParallelism, completeOnFailure);
/// Generate an initial docfx.json following the instructions.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --apiGlobPattern via
- --apiSourceFolder via
- --file via
- --help via
- --output via
- --overwrite via
- --quiet via
public static IReadOnlyCollection DocFXInit(DocFXInitSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXInit(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXInitSettings()));
- ///
+ ///
public static IEnumerable<(DocFXInitSettings Settings, IReadOnlyCollection Output)> DocFXInit(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXInit, degreeOfParallelism, completeOnFailure);
/// Merge .net base API in YAML files and toc files.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <configFile> via
- --content via
- --correlationId via
- --fileMetadataFile via
- --globalMetadata via
- --globalMetadataFile via
- --help via
- --log via
- --logLevel via
- --repositoryRoot via
- --tocMetadata via
- --warningsAsErrors via
public static IReadOnlyCollection DocFXMerge(DocFXMergeSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXMerge(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXMergeSettings()));
- ///
+ ///
public static IEnumerable<(DocFXMergeSettings Settings, IReadOnlyCollection Output)> DocFXMerge(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXMerge, degreeOfParallelism, completeOnFailure);
/// Generate YAML files from source code.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <projects> via
- --correlationId via
- --disableDefaultFilter via
- --disableGitFeatures via
- --filter via
- --force via
- --globalNamespaceId via
- --help via
- --log via
- --logLevel via
- --output via
- --property via
- --raw via
- --repositoryRoot via
- --shouldSkipMarkup via
- --warningsAsErrors via
public static IReadOnlyCollection DocFXMetadata(DocFXMetadataSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXMetadata(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXMetadataSettings()));
- ///
+ ///
public static IEnumerable<(DocFXMetadataSettings Settings, IReadOnlyCollection Output)> DocFXMetadata(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXMetadata, degreeOfParallelism, completeOnFailure);
/// Generate pdf file.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <configFile> via
- --basePath via
- --changesFile via
- --cleanupCacheHistory via
- --content via
- --correlationId via
- --css via
- --debug via
- --debugOutput via
- --disableGitFeatures via
- --dryRun via
- --errorHandling via
- --excludedTocs via
- --exportRawModel via
- --exportViewModel via
- --falName via
- --fileMetadataFile via
- --fileMetadataFiles via
- --force via
- --forcePostProcess via
- --generatesAppendices via
- --generatesExternalLink via
- --globalMetadata via
- --globalMetadataFile via
- --globalMetadataFiles via
- --help via
- --host via
- --hostname via
- --intermediateFolder via
- --keepFileLink via
- --keepRawFiles via
- --locale via
- --log via
- --logLevel via
- --lruSize via
- --markdownEngineName via
- --markdownEngineProperties via
- --maxParallelism via
- --name via
- --noLangKeyword via
- --noStdin via
- --output via
- --overwrite via
- --port via
- --postProcessors via
- --rawModelOutputFolder via
- --rawOutputFolder via
- --repositoryRoot via
- --resource via
- --schemaLicense via
- --serve via
- --template via
- --theme via
- --viewModelOutputFolder via
- --warningsAsErrors via
- --xref via
public static IReadOnlyCollection DocFXPdf(DocFXPdfSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXPdf(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXPdfSettings()));
- ///
+ ///
public static IEnumerable<(DocFXPdfSettings Settings, IReadOnlyCollection Output)> DocFXPdf(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXPdf, degreeOfParallelism, completeOnFailure);
/// Host a local static website.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <folder> via
- --help via
- --hostname via
- --port via
public static IReadOnlyCollection DocFXServe(DocFXServeSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXServe(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXServeSettings()));
- ///
+ ///
public static IEnumerable<(DocFXServeSettings Settings, IReadOnlyCollection Output)> DocFXServe(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXServe, degreeOfParallelism, completeOnFailure);
/// List or export existing template.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <command> via
- --all via
- --help via
- --output via
public static IReadOnlyCollection DocFXTemplate(DocFXTemplateSettings options = null) => new DocFXTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DocFXTemplate(Configure configurator) => new DocFXTasks().Run(configurator.Invoke(new DocFXTemplateSettings()));
- ///
+ ///
public static IEnumerable<(DocFXTemplateSettings Settings, IReadOnlyCollection Output)> DocFXTemplate(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DocFXTemplate, degreeOfParallelism, completeOnFailure);
}
#region DocFXBuildSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXBuild), Arguments = "build")]
public partial class DocFXBuildSettings : ToolOptions
@@ -194,7 +189,7 @@ public partial class DocFXBuildSettings : ToolOptions
}
#endregion
#region DocFXDependencySettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXDependency), Arguments = "dependency")]
public partial class DocFXDependencySettings : ToolOptions
@@ -210,7 +205,7 @@ public partial class DocFXDependencySettings : ToolOptions
}
#endregion
#region DocFXDownloadSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXDownload), Arguments = "download")]
public partial class DocFXDownloadSettings : ToolOptions
@@ -224,7 +219,7 @@ public partial class DocFXDownloadSettings : ToolOptions
}
#endregion
#region DocFXHelpSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXHelp), Arguments = "help")]
public partial class DocFXHelpSettings : ToolOptions
@@ -234,7 +229,7 @@ public partial class DocFXHelpSettings : ToolOptions
}
#endregion
#region DocFXInitSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXInit), Arguments = "init")]
public partial class DocFXInitSettings : ToolOptions
@@ -256,7 +251,7 @@ public partial class DocFXInitSettings : ToolOptions
}
#endregion
#region DocFXMergeSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXMerge), Arguments = "merge")]
public partial class DocFXMergeSettings : ToolOptions
@@ -288,7 +283,7 @@ public partial class DocFXMergeSettings : ToolOptions
}
#endregion
#region DocFXMetadataSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXMetadata), Arguments = "metadata")]
public partial class DocFXMetadataSettings : ToolOptions
@@ -328,7 +323,7 @@ public partial class DocFXMetadataSettings : ToolOptions
}
#endregion
#region DocFXPdfSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXPdf), Arguments = "pdf")]
public partial class DocFXPdfSettings : ToolOptions
@@ -448,7 +443,7 @@ public partial class DocFXPdfSettings : ToolOptions
}
#endregion
#region DocFXServeSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXServe), Arguments = "serve")]
public partial class DocFXServeSettings : ToolOptions
@@ -464,7 +459,7 @@ public partial class DocFXServeSettings : ToolOptions
}
#endregion
#region DocFXTemplateSettings
-///
+///
[ExcludeFromCodeCoverage]
[Command(Type = typeof(DocFXTasks), Command = nameof(DocFXTasks.DocFXTemplate), Arguments = "template")]
public partial class DocFXTemplateSettings : ToolOptions
@@ -480,7 +475,7 @@ public partial class DocFXTemplateSettings : ToolOptions
}
#endregion
#region DocFXBuildSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXBuildSettingsExtensions
{
@@ -1091,7 +1086,7 @@ public static partial class DocFXBuildSettingsExtensions
}
#endregion
#region DocFXDependencySettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXDependencySettingsExtensions
{
@@ -1139,7 +1134,7 @@ public static partial class DocFXDependencySettingsExtensions
}
#endregion
#region DocFXDownloadSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXDownloadSettingsExtensions
{
@@ -1179,7 +1174,7 @@ public static partial class DocFXDownloadSettingsExtensions
}
#endregion
#region DocFXHelpSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXHelpSettingsExtensions
{
@@ -1194,7 +1189,7 @@ public static partial class DocFXHelpSettingsExtensions
}
#endregion
#region DocFXInitSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXInitSettingsExtensions
{
@@ -1293,7 +1288,7 @@ public static partial class DocFXInitSettingsExtensions
}
#endregion
#region DocFXMergeSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXMergeSettingsExtensions
{
@@ -1444,7 +1439,7 @@ public static partial class DocFXMergeSettingsExtensions
}
#endregion
#region DocFXMetadataSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXMetadataSettingsExtensions
{
@@ -1666,7 +1661,7 @@ public static partial class DocFXMetadataSettingsExtensions
}
#endregion
#region DocFXPdfSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXPdfSettingsExtensions
{
@@ -2424,7 +2419,7 @@ public static partial class DocFXPdfSettingsExtensions
}
#endregion
#region DocFXServeSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXServeSettingsExtensions
{
@@ -2472,7 +2467,7 @@ public static partial class DocFXServeSettingsExtensions
}
#endregion
#region DocFXTemplateSettingsExtensions
-///
+///
[ExcludeFromCodeCoverage]
public static partial class DocFXTemplateSettingsExtensions
{
diff --git a/src/Fallout.Common/Tools/DocFX/DocFX.json b/src/Fallout.Application.Tools/DocFX/DocFX.json
similarity index 100%
rename from src/Fallout.Common/Tools/DocFX/DocFX.json
rename to src/Fallout.Application.Tools/DocFX/DocFX.json
diff --git a/src/Fallout.Common/Tools/DocFX/DocFXTasks.cs b/src/Fallout.Application.Tools/DocFX/DocFXTasks.cs
similarity index 83%
rename from src/Fallout.Common/Tools/DocFX/DocFXTasks.cs
rename to src/Fallout.Application.Tools/DocFX/DocFXTasks.cs
index f47be9417..3869cafdc 100644
--- a/src/Fallout.Common/Tools/DocFX/DocFXTasks.cs
+++ b/src/Fallout.Application.Tools/DocFX/DocFXTasks.cs
@@ -1,7 +1,7 @@
-using Fallout.Common.Tooling;
using Serilog.Events;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.DocFX;
+namespace Fallout.Application.Tools.DocFX;
[LogLevelPattern(LogEventLevel.Warning, $@"{TimestampPattern}Info\:\[ExtractMetadata\]No\ files\ are\ found")]
[LogLevelPattern(LogEventLevel.Warning, $@"{TimestampPattern}Warning\:")]
diff --git a/src/Fallout.Common/Tools/Docker/Docker.Generated.cs b/src/Fallout.Application.Tools/Docker/Docker.Generated.cs
similarity index 96%
rename from src/Fallout.Common/Tools/Docker/Docker.Generated.cs
rename to src/Fallout.Application.Tools/Docker/Docker.Generated.cs
index 1a7b39d91..41f800964 100644
--- a/src/Fallout.Common/Tools/Docker/Docker.Generated.cs
+++ b/src/Fallout.Application.Tools/Docker/Docker.Generated.cs
@@ -1,9 +1,3 @@
-// Generated from https://github.com/ChrisonSimtian/Fallout/blob/main/src/Fallout.Common/Tools/Docker/Docker.json
-
-using Fallout.Common;
-using Fallout.Common.Tooling;
-using Fallout.Common.Tools;
-using Fallout.Common.Utilities.Collections;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
@@ -13,8 +7,10 @@
using System.Linq;
using System.Text;
using System.Text.Json.Serialization;
+using Fallout.Application;
+using Fallout.Application.Tooling;
-namespace Fallout.Common.Tools.Docker;
+namespace Fallout.Application.Tools.Docker;
/// Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.
For more details, visit the official website.
[ExcludeFromCodeCoverage]
@@ -28,1315 +24,1315 @@ public partial class DockerTasks : ToolTasks, IRequirePathTool
/// Remove one or more configs.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <configs> via
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerConfigRm(DockerConfigRmSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerConfigRm(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerConfigRmSettings()));
- ///
+ ///
public static IEnumerable<(DockerConfigRmSettings Settings, IReadOnlyCollection Output)> DockerConfigRm(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerConfigRm, degreeOfParallelism, completeOnFailure);
/// Load an image from a tar archive or STDIN.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --input via
- --log-level via
- --quiet via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerLoad(DockerLoadSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerLoad(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerLoadSettings()));
- ///
+ ///
public static IEnumerable<(DockerLoadSettings Settings, IReadOnlyCollection Output)> DockerLoad(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerLoad, degreeOfParallelism, completeOnFailure);
/// Remove all stopped containers.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --filter via
- --force via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerContainerPrune(DockerContainerPruneSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerContainerPrune(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerContainerPruneSettings()));
- ///
+ ///
public static IEnumerable<(DockerContainerPruneSettings Settings, IReadOnlyCollection Output)> DockerContainerPrune(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerContainerPrune, degreeOfParallelism, completeOnFailure);
/// Manage trust on Docker images.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerTrust(DockerTrustSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerTrust(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerTrustSettings()));
- ///
+ ///
public static IEnumerable<(DockerTrustSettings Settings, IReadOnlyCollection Output)> DockerTrust(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerTrust, degreeOfParallelism, completeOnFailure);
/// Manage Docker stacks.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --kubeconfig via
- --log-level via
- --orchestrator via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerStack(DockerStackSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerStack(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerStackSettings()));
- ///
+ ///
public static IEnumerable<(DockerStackSettings Settings, IReadOnlyCollection Output)> DockerStack(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerStack, degreeOfParallelism, completeOnFailure);
/// Pull an image or a repository from a registry.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <name> via
- --all-tags via
- --config via
- --debug via
- --disable-content-trust via
- --log-level via
- --platform via
- --quiet via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerPull(DockerPullSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerPull(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerPullSettings()));
- ///
+ ///
public static IEnumerable<(DockerPullSettings Settings, IReadOnlyCollection Output)> DockerPull(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerPull, degreeOfParallelism, completeOnFailure);
/// Sign an image.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerTrustSign(DockerTrustSignSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerTrustSign(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerTrustSignSettings()));
- ///
+ ///
public static IEnumerable<(DockerTrustSignSettings Settings, IReadOnlyCollection Output)> DockerTrustSign(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerTrustSign, degreeOfParallelism, completeOnFailure);
/// Manage checkpoints.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerCheckpoint(DockerCheckpointSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerCheckpoint(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerCheckpointSettings()));
- ///
+ ///
public static IEnumerable<(DockerCheckpointSettings Settings, IReadOnlyCollection Output)> DockerCheckpoint(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerCheckpoint, degreeOfParallelism, completeOnFailure);
/// Manage entities who can sign Docker images.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerTrustSigner(DockerTrustSignerSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerTrustSigner(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerTrustSignerSettings()));
- ///
+ ///
public static IEnumerable<(DockerTrustSignerSettings Settings, IReadOnlyCollection Output)> DockerTrustSigner(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerTrustSigner, degreeOfParallelism, completeOnFailure);
/// Display detailed information on one or more configs.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <configs> via
- --config via
- --debug via
- --format via
- --log-level via
- --pretty via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerConfigInspect(DockerConfigInspectSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerConfigInspect(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerConfigInspectSettings()));
- ///
+ ///
public static IEnumerable<(DockerConfigInspectSettings Settings, IReadOnlyCollection Output)> DockerConfigInspect(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerConfigInspect, degreeOfParallelism, completeOnFailure);
/// Manage services.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerService(DockerServiceSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerService(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerServiceSettings()));
- ///
+ ///
public static IEnumerable<(DockerServiceSettings Settings, IReadOnlyCollection Output)> DockerService(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerService, degreeOfParallelism, completeOnFailure);
/// Generate and load a signing key-pair.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <name> via
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerTrustKeyGenerate(DockerTrustKeyGenerateSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerTrustKeyGenerate(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerTrustKeyGenerateSettings()));
- ///
+ ///
public static IEnumerable<(DockerTrustKeyGenerateSettings Settings, IReadOnlyCollection Output)> DockerTrustKeyGenerate(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerTrustKeyGenerate, degreeOfParallelism, completeOnFailure);
/// Manage Docker.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerSystem(DockerSystemSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerSystem(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerSystemSettings()));
- ///
+ ///
public static IEnumerable<(DockerSystemSettings Settings, IReadOnlyCollection Output)> DockerSystem(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerSystem, degreeOfParallelism, completeOnFailure);
/// List configs.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --filter via
- --format via
- --log-level via
- --quiet via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerConfigLs(DockerConfigLsSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerConfigLs(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerConfigLsSettings()));
- ///
+ ///
public static IEnumerable<(DockerConfigLsSettings Settings, IReadOnlyCollection Output)> DockerConfigLs(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerConfigLs, degreeOfParallelism, completeOnFailure);
/// Update a context.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <context> via
- --config via
- --debug via
- --default-stack-orchestrator via
- --description via
- --docker via
- --kubernetes via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerContextUpdate(DockerContextUpdateSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerContextUpdate(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerContextUpdateSettings()));
- ///
+ ///
public static IEnumerable<(DockerContextUpdateSettings Settings, IReadOnlyCollection Output)> DockerContextUpdate(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerContextUpdate, degreeOfParallelism, completeOnFailure);
/// List the services in the stack.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <stack> via
- --config via
- --debug via
- --filter via
- --format via
- --kubeconfig via
- --log-level via
- --namespace via
- --orchestrator via
- --quiet via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerStackServices(DockerStackServicesSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerStackServices(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerStackServicesSettings()));
- ///
+ ///
public static IEnumerable<(DockerStackServicesSettings Settings, IReadOnlyCollection Output)> DockerStackServices(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerStackServices, degreeOfParallelism, completeOnFailure);
/// List port mappings or a specific mapping for the container.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <container> via
- <privatePort> via
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerContainerPort(DockerContainerPortSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerContainerPort(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerContainerPortSettings()));
- ///
+ ///
public static IEnumerable<(DockerContainerPortSettings Settings, IReadOnlyCollection Output)> DockerContainerPort(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerContainerPort, degreeOfParallelism, completeOnFailure);
/// Rename a container.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <container> via
- <newName> via
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerRename(DockerRenameSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerRename(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerRenameSettings()));
- ///
+ ///
public static IEnumerable<(DockerRenameSettings Settings, IReadOnlyCollection Output)> DockerRename(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerRename, degreeOfParallelism, completeOnFailure);
/// Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <sourceImage> via
- <targetImage> via
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerTag(DockerTagSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerTag(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerTagSettings()));
- ///
+ ///
public static IEnumerable<(DockerTagSettings Settings, IReadOnlyCollection Output)> DockerTag(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerTag, degreeOfParallelism, completeOnFailure);
/// Display detailed information on one or more secrets.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <secrets> via
- --config via
- --debug via
- --format via
- --log-level via
- --pretty via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerSecretInspect(DockerSecretInspectSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerSecretInspect(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerSecretInspectSettings()));
- ///
+ ///
public static IEnumerable<(DockerSecretInspectSettings Settings, IReadOnlyCollection Output)> DockerSecretInspect(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerSecretInspect, degreeOfParallelism, completeOnFailure);
/// Manage Docker secrets.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- --config via
- --debug via
- --log-level via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerSecret(DockerSecretSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerSecret(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerSecretSettings()));
- ///
+ ///
public static IEnumerable<(DockerSecretSettings Settings, IReadOnlyCollection Output)> DockerSecret(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerSecret, degreeOfParallelism, completeOnFailure);
/// Export a container's filesystem as a tar archive.
For more details, visit the official website.
/// This is a CLI wrapper with fluent API that allows to modify the following arguments:
- <container> via
- --config via
- --debug via
- --log-level via
- --output via
- --tls via
- --tlscacert via
- --tlscert via
- --tlskey via
- --tlsverify via
public static IReadOnlyCollection DockerContainerExport(DockerContainerExportSettings options = null) => new DockerTasks().Run(options);
- ///
+ ///
public static IReadOnlyCollection DockerContainerExport(Configure configurator) => new DockerTasks().Run(configurator.Invoke(new DockerContainerExportSettings()));
- ///
+ ///
public static IEnumerable<(DockerContainerExportSettings Settings, IReadOnlyCollection Output)> DockerContainerExport(CombinatorialConfigure configurator, int degreeOfParallelism = 1, bool completeOnFailure = false) => configurator.Invoke(DockerContainerExport, degreeOfParallelism, completeOnFailure);
///