A C# build-orchestration project that consolidates all CI/CD logic into testable, locally-runnable Bullseye targets. The GitHub Actions workflows become thin wrappers that delegate to this project, keeping YAML minimal and all real logic in C#.

• .NET 8 SDK (or newer)

No other tools are required — all dependencies (Bullseye, SimpleExec) are restored automatically.

# From the repository root
dotnet run --project NxGraph.Build -- <target> [target2 ...]

Bullseye supports passing multiple targets in a single invocation. Shared dependencies (e.g. restore, build) are automatically de-duplicated and only executed once.

publish
├── ci
│   └── test
│       └── build
│           └── restore
└── push
    └── pack
        └── build
            └── restore

dotnet run --project NxGraph.Build -- ci

This runs restore → build → test with code-coverage. Equivalent to what the dotnet.yml workflow does on every push/PR.

COVERAGE_THRESHOLD=80 dotnet run --project NxGraph.Build -- ci

On Windows (PowerShell):

$env:COVERAGE_THRESHOLD = "80"
dotnet run --project NxGraph.Build -- ci

# Pack all packages at version 1.2.3
TARGET=all VERSION=1.2.3 dotnet run --project NxGraph.Build -- pack

# Pack only the Serialization package
TARGET=serialization VERSION=2.0.0-beta.1 dotnet run --project NxGraph.Build -- pack

On Windows (PowerShell):

$env:TARGET = "all"
$env:VERSION = "1.2.3"
dotnet run --project NxGraph.Build -- pack

TARGET=all \
VERSION=1.2.3 \
NUGET_API_KEY=your-api-key \
  dotnet run --project NxGraph.Build -- publish

This is the single command the publish-nuget.yml workflow runs.

dotnet run --project NxGraph.Build -- stage-source

dotnet run --project NxGraph.Build -- stage-binary

VERSION=1.0.0 dotnet run --project NxGraph.Build -- ci stage-binary upm-patch-version upm-tarball

Bullseye runs all four targets (and their transitive dependencies) in a single process. This is what the upm-release.yml workflow runs — the remaining git-push and GitHub Release steps stay in YAML because they need authenticated git operations.

dotnet run --project NxGraph.Build -- clean

dotnet run --project NxGraph.Build -- --list-targets

dotnet run --project NxGraph.Build -- --list-tree publish

All configuration is passed via environment variables. Values that are not set fall back to sensible defaults for local development.

In CI, these are set automatically by the GitHub Actions workflows. For local use, only TARGET and VERSION are needed for pack/UPM commands; everything else has defaults.

The YAML files only contain what must stay in GitHub Actions: triggers, permissions, concurrency groups, checkout, SDK setup, secret masking, artifact upload, git push, and GitHub Release creation.

All real logic (restore, build, test, pack, push, staging, version patching, tarball creation) lives in the build project, making it easy to run and debug locally.

NxGraph.Build/
├── NxGraph.Build.csproj   # Project file (Bullseye + SimpleExec references)
├── Program.cs             # Bullseye target definitions + UPM staging logic
├── BuildHelpers.cs        # Shared utilities (SemVer, paths, pack args, tarball, etc.)
└── README.md              # This file

NxGraph.Build outputs its binaries to .tools/ at the repository root instead of the conventional bin/ and obj/ directories. This keeps build-tool artifacts (NxGraph.Build.exe, Bullseye.dll, SimpleExec.dll, etc.) completely separated from the actual project outputs.

.tools/                ← git-ignored, build-tool output only
├── bin/
│   ├── Debug/net8.0/  ← local dev (dotnet run)
│   └── Release/net8.0/← CI
└── obj/               ← intermediate files

Additionally, NxGraph.Build is excluded from the solution-level Release build. When CI runs dotnet build -c Release on the solution, it only builds the library, test, and example projects — not the build tool itself. The tool is built on-demand by dotnet run --project NxGraph.Build.

Note: The Debug configuration still includes NxGraph.Build in the solution build for IDE convenience (IntelliSense, error highlighting, etc.).