Rewritten in C#

.gitignore

@@ -64,6 +64,7 @@ Generated\ Files/
 # MSTest test Results
 [Tt]est[Rr]esult*/
 [Bb]uild[Ll]og.*
+testResults.xml
 
 # NUnit
 *.VisualState.xml
@@ -386,4 +387,4 @@ FodyWeavers.xsd
 
 /.idea/
 CLAUDE.md
-.claude/*
+.claude/*

Build/Build-PowerForge.ps1

@@ -0,0 +1,174 @@
+[CmdletBinding()] param(
+    [ValidateSet('win-x64', 'win-arm64', 'linux-x64', 'linux-arm64', 'linux-musl-x64', 'linux-musl-arm64', 'osx-x64', 'osx-arm64')]
+    [string[]] $Runtime = @('win-x64'),
+    [ValidateSet('Debug', 'Release')]
+    [string] $Configuration = 'Release',
+    [ValidateSet('net10.0', 'net8.0')]
+    [string] $Framework = 'net10.0',
+    [ValidateSet('SingleContained', 'SingleFx', 'Portable', 'Fx')]
+    [string] $Flavor = 'SingleContained',
+    [string] $OutDir,
+    [switch] $ClearOut,
+    [switch] $Zip,
+    [switch] $UseStaging = $true,
+    [switch] $KeepSymbols,
+    [switch] $KeepDocs
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+function Write-Header($t) { Write-Host "`n=== $t ===" -ForegroundColor Cyan }
+function Write-Ok($t) { Write-Host "[OK] $t" -ForegroundColor Green }
+function Write-Step($t) { Write-Host "[+] $t" -ForegroundColor Yellow }
+
+$repoRoot = (Resolve-Path -LiteralPath ([IO.Path]::GetFullPath([IO.Path]::Combine($PSScriptRoot, '..')))).Path
+$proj = Join-Path $repoRoot 'PowerForge.Cli/PowerForge.Cli.csproj'
+
+if (-not (Test-Path -LiteralPath $proj)) { throw "Project not found: $proj" }   
+
+# When using a staging publish dir, treat the output as an exact snapshot and clear it by default.
+if ($UseStaging -and -not $PSBoundParameters.ContainsKey('ClearOut')) {
+    $ClearOut = $true
+}
+
+$outDirProvided = $PSBoundParameters.ContainsKey('OutDir')
+$rids = @(
+    @($Runtime) |
+        Where-Object { $_ -and $_.Trim() } |
+        ForEach-Object { $_.Trim() } |
+        Select-Object -Unique
+)
+if ($rids.Count -eq 0) { throw "Runtime must not be empty." }
+$multiRuntime = $rids.Count -gt 1
+
+function Resolve-OutDir {
+    param([Parameter(Mandatory)][string] $Rid)
+    if ($outDirProvided) {
+        if ($multiRuntime) {
+            return Join-Path $OutDir ("{0}/{1}/{2}" -f $Rid, $Framework, $Flavor)
+        }
+        return $OutDir
+    }
+    return Join-Path $repoRoot ("Artifacts/PowerForge/{0}/{1}/{2}" -f $Rid, $Framework, $Flavor)
+}
+
+$singleFile = $Flavor -in @('SingleContained', 'SingleFx')
+$selfContained = $Flavor -in @('SingleContained', 'Portable')
+$compress = $singleFile
+$selfExtract = $Flavor -eq 'SingleContained'
+
+Write-Header "Build PowerForge ($Flavor)"
+Write-Step "Framework -> $Framework"
+Write-Step "Configuration -> $Configuration"
+Write-Step ("Runtimes -> {0}" -f ($rids -join ', '))
+
+foreach ($rid in $rids) {
+    $outDirThis = Resolve-OutDir -Rid $rid
+    New-Item -ItemType Directory -Force -Path $outDirThis | Out-Null
+
+    $publishDir = $outDirThis
+    $stagingDir = $null
+    if ($UseStaging) {
+        $stagingDir = Join-Path $env:TEMP ("PowerForge.Cli.publish." + [guid]::NewGuid().ToString("N"))
+        $publishDir = $stagingDir
+        Write-Step "Using staging publish dir -> $publishDir"
+        if (Test-Path $publishDir) {
+            Remove-Item -Path $publishDir -Recurse -Force -ErrorAction SilentlyContinue
+        }
+        New-Item -ItemType Directory -Force -Path $publishDir | Out-Null
+    }
+
+    Write-Step "Runtime -> $rid"
+    Write-Step "Publishing -> $publishDir"
+
+    $publishArgs = @(
+        'publish', $proj,
+        '-c', $Configuration,
+        '-f', $Framework,
+        '-r', $rid,
+        "--self-contained:$selfContained",
+        "/p:PublishSingleFile=$singleFile",
+        "/p:PublishReadyToRun=false",
+        "/p:PublishTrimmed=false",
+        "/p:IncludeAllContentForSelfExtract=$singleFile",
+        "/p:IncludeNativeLibrariesForSelfExtract=$selfExtract",
+        "/p:EnableCompressionInSingleFile=$compress",
+        "/p:DebugType=None",
+        "/p:DebugSymbols=false",
+        "/p:GenerateDocumentationFile=false",
+        "/p:CopyDocumentationFiles=false",
+        "/p:ExcludeSymbolsFromSingleFile=true",
+        "/p:ErrorOnDuplicatePublishOutputFiles=false",
+        "/p:UseAppHost=true",
+        "/p:PublishDir=$publishDir"
+    )
+
+    if ($ClearOut -and (Test-Path $outDirThis) -and ($publishDir -eq $outDirThis)) {
+        Write-Step "Clearing $outDirThis"
+        Get-ChildItem -Path $outDirThis -Recurse -Force -ErrorAction SilentlyContinue |
+            Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
+    }
+
+    dotnet.exe @publishArgs
+    if ($LASTEXITCODE -ne 0) { throw "Publish failed ($LASTEXITCODE)" }
+
+    if (-not $KeepSymbols) {
+        Write-Step "Removing symbols (*.pdb)"
+        Get-ChildItem -Path $publishDir -Filter *.pdb -File -Recurse -ErrorAction SilentlyContinue |
+            Remove-Item -Force -ErrorAction SilentlyContinue
+    }
+
+    if (-not $KeepDocs) {
+        Write-Step "Removing docs (*.xml, *.pdf)"
+        Get-ChildItem -Path $publishDir -File -Recurse -ErrorAction SilentlyContinue |
+            Where-Object { $_.Extension -in @('.xml', '.pdf') } |
+            Remove-Item -Force -ErrorAction SilentlyContinue
+    }
+
+    $ridIsWindows = $rid -like 'win-*'
+    $cliExe = Join-Path $publishDir 'PowerForge.Cli.exe'
+    $cliExeAlt = Join-Path $publishDir 'PowerForge.Cli'
+    $friendlyExe = Join-Path $publishDir ($ridIsWindows ? 'powerforge.exe' : 'powerforge')
+    foreach ($candidate in @($cliExe, $cliExeAlt)) {
+        if (-not (Test-Path -LiteralPath $candidate)) { continue }
+
+        # Keep a stable, user-friendly binary name without duplicating 50+ MB on disk.
+        if (Test-Path -LiteralPath $friendlyExe) {
+            Remove-Item -LiteralPath $friendlyExe -Force -ErrorAction SilentlyContinue
+        }
+        Move-Item -LiteralPath $candidate -Destination $friendlyExe -Force
+        break
+    }
+
+    if ($ClearOut -and (Test-Path $outDirThis) -and ($publishDir -ne $outDirThis)) {
+        Write-Step "Clearing $outDirThis"
+        Get-ChildItem -Path $outDirThis -Recurse -Force -ErrorAction SilentlyContinue |
+            Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
+    }
+
+    if ($publishDir -ne $outDirThis) {
+        Write-Step "Copying publish output -> $outDirThis"
+        Copy-Item -Path (Join-Path $publishDir '*') -Destination $outDirThis -Recurse -Force
+    }
+
+    if ($Zip) {
+        $zipName = "PowerForge-" + $Framework + "-" + $rid + "-" + $Flavor + "-" + (Get-Date -Format 'yyyyMMdd-HHmm') + ".zip"
+        $zipPath = Join-Path (Split-Path -Parent $outDirThis) $zipName
+        if (Test-Path $zipPath) { Remove-Item -Force $zipPath }
+        Write-Step ("Create zip -> {0}" -f $zipPath)
+        Add-Type -AssemblyName System.IO.Compression.FileSystem
+        [System.IO.Compression.ZipFile]::CreateFromDirectory($outDirThis, $zipPath)
+    }
+
+    if ($stagingDir -and (Test-Path $stagingDir)) {
+        Remove-Item -Path $stagingDir -Recurse -Force -ErrorAction SilentlyContinue
+    }
+}
+
+if ($multiRuntime) {
+    $root = if ($outDirProvided) { $OutDir } else { Join-Path $repoRoot 'Artifacts/PowerForge' }
+    Write-Ok ("Built PowerForge -> {0}" -f $root)
+} else {
+    Write-Ok ("Built PowerForge -> {0}" -f (Resolve-OutDir -Rid $rids[0]))
+}

CONTRIBUTING.md

@@ -0,0 +1,27 @@
+# Contributing
+
+## Repo goals
+
+- Keep **core logic** in `PowerForge` (C#) so it can be reused by:
+  - PowerShell cmdlets (`PSPublishModule`)
+  - CLI (`PowerForge.Cli`)
+  - GitHub Actions / future VSCode extension
+- Keep **cmdlets thin**: parameter binding + `ShouldProcess` + call core service + typed output.
+- Prefer **typed models/enums**; keep `Hashtable/OrderedDictionary` only for legacy adapters.
+
+## Build
+
+- `dotnet build .\\PSPublishModule.sln -c Release`
+
+## Tests
+
+- C# unit tests: `dotnet test .\\PSPublishModule.sln -c Release`
+- Pester tests: `Invoke-Pester -Path .\\Module\\Tests -CI`
+
+## Adding/Refactoring a cmdlet
+
+1. Create/extend a typed service in `PowerForge` (spec/result models in `PowerForge/Models`).
+2. Create/update a thin cmdlet in `PSPublishModule/Cmdlets` that calls the service.
+3. Remove legacy PowerShell functions once replaced (avoid duplicate implementations).
+4. Add unit tests (xUnit) and/or Pester coverage for the public behavior.
+

Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+  <PropertyGroup>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+</Project>

JSON_SCHEMA.md

@@ -0,0 +1,65 @@
+# PowerForge CLI JSON Schema
+
+PowerForge CLI commands accept JSON configuration files (`--config <file.json>`). This repository ships a **baseline JSON Schema** set intended for editor validation (VSCode) and for building future tooling (e.g., a VSCode extension).
+
+## Input config schemas (v1)
+
+- Build: `schemas/powerforge.buildspec.schema.json` (maps to `PowerForge.ModuleBuildSpec`)
+- Install: `schemas/powerforge.installspec.schema.json` (maps to `PowerForge.ModuleInstallSpec`)
+- Test: `schemas/powerforge.testsuitespec.schema.json` (maps to `PowerForge.ModuleTestSuiteSpec`)
+- DotNet publish: `schemas/powerforge.dotnetpublish.schema.json` (maps to `PowerForge.DotNetPublishSpec`)
+- Pipeline / Plan: `schemas/powerforge.pipelinespec.schema.json` (maps to `PowerForge.ModulePipelineSpec`)
+  - Segments: `schemas/powerforge.segments.schema.json` (maps to `PowerForge.IConfigurationSegment` + concrete segment types)
+- Shared enums: `schemas/powerforge.common.schema.json`
+
+## Using with VSCode
+
+Add a `$schema` property to your JSON file (PowerForge ignores unknown properties during deserialization):
+
+```json
+{
+  "$schema": "./schemas/powerforge.pipelinespec.schema.json",
+  "SchemaVersion": 1,
+  "Build": {
+    "Name": "MyModule",
+    "SourcePath": ".",
+    "Version": "1.0.0",
+    "Frameworks": ["net472", "net8.0", "net10.0"]
+  },
+  "Install": {
+    "Enabled": true,
+    "Strategy": "AutoRevision",
+    "KeepVersions": 3
+  },
+  "Segments": [
+    { "Type": "Manifest", "Configuration": { "Author": "Me" } },
+    { "Type": "Packed", "Configuration": { "Enabled": true, "Path": "Artefacts" } }
+  ]
+}
+```
+
+## Segment type discriminators
+
+Segments use a required `Type` discriminator (case-insensitive). Supported `Type` values include:
+
+- Fixed: `Manifest`, `Build`, `BuildLibraries`, `Information`, `Options`, `Formatting`, `Documentation`, `BuildDocumentation`, `ImportModules`, `ModuleSkip`, `Command`, `PlaceHolder`, `PlaceHolderOption`, `Compatibility`, `FileConsistency`, `TestsAfterMerge`
+- Publish: `GalleryNuget`, `GitHubNuget`
+- Artefacts: `Unpacked`, `Packed`, `Script`, `ScriptPacked`
+- Module dependencies: `RequiredModule`, `ExternalModule`, `ApprovedModule`
+
+## Notes
+
+- Property names are treated case-insensitively by PowerForge (`System.Text.Json` options); the schemas use canonical PascalCase names.
+- The CLI config parser allows JSON comments and trailing commas; many JSON Schema validators do not.
+- `Version` supports the special value `"auto"` for build/pipeline/install configs (reads `ModuleVersion` from `<Name>.psd1`).
+
+## CLI JSON output
+
+When you run with `--output json`, stdout contains a single JSON object with a stable envelope:
+
+- `schemaVersion` (int)
+- `command` (string)
+- `success` (bool)
+- `exitCode` (int)
+- `error` (string, when `success=false`)
+- plus command-specific payload (`spec`, `result`, `logs`, etc.)

MIGRATION.md

@@ -0,0 +1,37 @@
+# PSPublishModule Migration Guide (PowerShell → C# Core + PowerShell + CLI)
+
+This repo is migrating from a PowerShell-only implementation to:
+
+- **`PowerForge` (C# library)**: the reusable core (build/docs/publish logic).
+- **`PSPublishModule` (PowerShell module)**: *thin* cmdlets (parameter binding + `ShouldProcess` + call `PowerForge`).
+- **`PowerForge.Cli` (CLI)**: non-PowerShell entrypoint for CI, GitHub Actions, and future VSCode extension scenarios.
+
+## What stays compatible
+
+- Existing module repos that call `Build\\Build-Module.ps1` should continue to work.
+- The “PowerShell configuration DSL” remains supported (typed segments now; legacy adapters only where unavoidable).
+
+## What changes (notable)
+
+- “Private” internal PowerShell helper functions are being removed as functionality moves to `PowerForge`.
+  - Don’t depend on internal functions like `Test-*` helpers from the module.
+  - Use the **public** cmdlets and/or the CLI.
+- Output is increasingly **typed** (classes/enums) rather than `Hashtable`/`OrderedDictionary`.
+
+## Recommended workflows
+
+### PowerShell (interactive)
+
+- Keep using existing build scripts, but prefer cmdlets that route through `PowerForge` services.
+- When developing PSPublishModule itself, prefer **staging-first** builds to avoid file-locking (“in use”) issues.
+
+### CLI (CI / GitHub Actions / future VSCode)
+
+- Prefer JSON-driven execution so CI and tooling can call a stable contract.
+- Typical flow: `plan` → `pipeline`/`build` with `--output json` and CI-safe UI settings.
+
+## Publishing (PowerShellGet + PSResourceGet)
+
+- Publishing is being unified behind `PowerForge` publishers.
+- **No standalone “PSResourceGet cmdlets”** are exposed; `PSResourceGet` is used internally where configured/appropriate.
+