Add a Windows CI job covering lint, compile, and test (#518)

[leynos]

Closes #518

Summary

Netsuke ships Windows binaries that no CI job ever compiles. 47
#[cfg(windows)] sites across 14 files were never linted, type-checked,
or tested, and reached users compiled for the first time at packaging
time — the worst place to discover a failure. This pull request adds a
build-test-windows job to .github/workflows/ci.yml that mirrors the
Linux build-test job on windows-latest, restricted to what is
platform-relevant.

What the job runs

• make check-fmt
• make lint-clippy (Clippy and cargo doc under -D warnings)
• make lint-whitaker (Whitaker installs and runs on Windows)
• make test (cargo-nextest + doctests under -D warnings -Zpolonius=next)

What is excluded (platform-independent, already covered on Linux)

• Documentation lints: make spelling, make markdownlint, make nixie
• Audit checks: coverage generation, the CodeScene coverage gate, and
  make test-workflow-contracts

Tooling provisioned for Windows

• GNU Make via Chocolatey (choco install make)
• Ninja via seanmiddleditch/gha-setup-ninja
• cargo-nextest via taiki-e/install-action, pinned to NEXTEST_VERSION
• Git Bash as the recipe shell (defaults.run.shell: bash), with every
  make invocation overriding SHELL to bash because GNU Make's Windows
  default recipe shell is cmd.exe
• The pinned nightly with -D warnings -Zpolonius=next passed through the
  shared setup-rust with.rustflags input, per the Polonius toolchain
  contract (no job-level env.RUSTFLAGS)
• whitaker-installer ships whitaker as a PowerShell wrapper on
  Windows; a bash shim in the cargo bin directory invokes it through
  PowerShell so make lint-whitaker can run it from Git Bash

Rollout posture

The job is a blocking merge gate: no continue-on-error remains on
the job or any of its steps, so a Windows failure or warning blocks the
merge. Making it blocking surfaced the never-compiled #[cfg(windows)]
surface under -D warnings; the findings were cleared at the source:

• dead-code and unused-import findings in test_support and the
  Windows-only test arms
• Clippy findings in Windows-only arms (missing_const_for_fn,
  unnecessary_wraps, needless_pass_by_value, shadowing, format-arg
  inlining, unused imports)
• Whitaker no_std_fs_operations findings in the Windows grep-stream
  test, routed through test_support::fs
• Whitaker's PowerShell wrapper on Windows, shimmed so the lint gate
  runs instead of failing on a missing command

Remaining Windows failures (blocking the merge)

The Test step currently fails on three cli::discovery tests on
windows-latest:

• cli::discovery::layer_tests::normalization_failure_does_not_fail_discovery
• cli::discovery::layer_tests::existing_project_scope_layer_is_not_appended_twice
• cli::discovery::tests::collect_diag_file_layers_uses_injected_explicit_config

These are pre-existing Windows path-identity bugs in src/cli/discovery*,
unrelated to the CI job change and out of this PR's scope. Root cause:
tempdir() returns short-name paths (C:\Users\RUNNER~1\...) on
Windows while ortho_config canonicalises layer paths to long names
(C:\Users\runneradmin\...), so the project-scope dedup key never
matches the recorded layer path and the layer is appended twice. They are
tracked for a follow-up; the job correctly blocks until they are fixed.

Known unknowns resolved during implementation

• GNU Make / POSIX shell: resolved via choco install make plus Git
  Bash with SHELL=bash overrides.
• Ninja on PATH: resolved via gha-setup-ninja and a ninja --version
  assertion step.
• Whitaker/Dylint on Windows: verified working — it installs and runs
  on windows-latest; the PowerShell wrapper is shimmed for Git Bash.
• make powershell-wrapper-validate: the target does not exist in the
  current Makefile, so it is not reachable and not added to this job.

cfg widening assessment (env.rs) — decision: keep the widening

DEFAULT_PATHEXT, default_pathext, and parse_pathext in
src/stdlib/which/env.rs are gated #[cfg(any(windows, test))] so the
Unix CI host could reach them (see #503). With a Windows job that
compiles and tests the #[cfg(windows)] arm directly, the widening was
reassessed:

• The original motivation — a CI host that never compiled Windows — is
  gone.
• But reverting to #[cfg(windows)] would drop Unix-host coverage of
  parse_pathext's pure string logic (normalization, de-duplication,
  fallback), which src/stdlib/which/pathext_tests.rs pins on every
  host. There is no equivalent Unix-side test for a Windows-only
  function.
• Decision: keep the widening. The pure string logic is exercised on
  both Linux and Windows, and a Windows-gated regression cannot hide
  from the Unix suite. Recorded in docs/developers-guide.md.

References

• Issue: #518
• Related: #505,
  #503,
  #493
• Lody session: https://lody.ai/leynos/sessions/42b6fe6d-a3cd-4399-abaf-9d1bd91a6278

Summary by Sourcery

Add a blocking Windows CI gate and harden platform-specific behavior so Windows builds, linting, and tests are validated before merge.

New Features:

• Add a blocking Windows CI job that compiles, lints, and tests Windows-specific code on windows-latest.
• Run platform-relevant formatting, Clippy, Whitaker, and test gates with Windows tool provisioning and Git Bash compatibility.

Bug Fixes:

• Fix Windows path identity and project configuration layer de-duplication across alternate path spellings.
• Fix Windows compatibility issues in temporary Ninja file handling, shell command execution, cache-path validation, and platform-specific tests.

Enhancements:

• Centralize the pinned cargo-nextest version at workflow scope and strengthen CI workflow contracts.
• Retain cross-platform coverage for host-independent PATHEXT logic while directly exercising Windows-gated behavior.

CI:

• Make the Windows job a non-optional merge gate and extend toolchain contract tests to cover it.
• Disable redundant automatic uv caching where explicit caches are already used and correct CodeScene coverage report wiring.

Documentation:

• Document the Windows CI gate, path normalization behavior, and the rationale for retaining cross-platform PATHEXT coverage.

Tests:

• Expand workflow contract tests for the Windows job, shared toolchain flags, nextest pinning, and gate composition.
• Add Windows and cross-platform regression coverage for configuration discovery, command execution, cache paths, Ninja handling, and platform-specific helpers.

[sourcery-ai]

Reviewer's Guide

Adds a non-blocking Windows CI job that mirrors the Linux build-test pipeline, provisioning Windows-specific tooling (GNU Make, Ninja, cargo-nextest, Whitaker) and running format, lint, and test targets under the pinned Polonius nightly toolchain.

Flow diagram for the new Windows CI build-test job

flowchart TD
  subgraph build-test-windows
    A[actions/checkout] --> B[Install_GNU_Make]
    B --> C[Setup_Rust]
    C --> D[Install_Ninja]
    D --> E[Install_cargo-nextest]
    E --> F[Show_rustc_version]
    F --> G[Show_Ninja_version]
    G --> H[Format: make check-fmt]
    H --> I[Lint_Clippy: make lint-clippy]
    I --> J[Cache_Whitaker_installer]
    J --> K[Install_Whitaker]
    K --> L[Lint_Whitaker: make lint-whitaker]
    L --> M[Test: make test]
  end

  classDef nonblocking stroke-dasharray: 3 3
  class K,L build-test-windows,nonblocking

Loading

File-Level Changes

Change	Details	Files
Introduce a Windows CI job that runs formatting, linting, and tests with a Windows toolchain while remaining non-blocking during rollout.	Add build-test-windows job configuration targeting windows-latest with continue-on-error enabled Define environment variables for Rust toolchain, build profile, Whitaker installer version, and cargo-nextest version Configure Git Bash as the default shell and override SHELL=bash in all make invocations Run make check-fmt, make lint-clippy, make lint-whitaker, and make test as the core steps of the job	.github/workflows/ci.yml
Provision and verify Windows-specific tooling required by the new CI job.	Install GNU Make via Chocolatey in the workflow steps Set up the pinned nightly Rust toolchain with rustfmt and clippy components and pass -D warnings -Zpolonius=next via setup-rust rustflags Install Ninja via gha-setup-ninja and assert its presence with a ninja --version step Install cargo-nextest via taiki-e/install-action using NEXTEST_VERSION from env and show rustc/cargo versions	.github/workflows/ci.yml
Integrate Whitaker linting in a non-blocking fashion on Windows, with caching for the installer.	Add an actions/cache step to cache whitaker-installer and cargo-binstall directories keyed by OS, architecture, and Whitaker installer version Install Whitaker using cargo-binstall if available or cargo install as a fallback, guarded by continue-on-error Run make lint-whitaker under continue-on-error so Clippy remains the primary Windows lint gate if Whitaker fails	.github/workflows/ci.yml

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#518	Add a windows-latest CI job that runs make check-fmt, Rust lints, and tests, compiling the #[cfg(windows)] code under -D warnings using appropriate Windows tooling.	✅
#518	Ensure the Windows CI job does not duplicate documentation lints or audit checks already covered by Linux CI.	✅
#518	Assess and record whether #[cfg(any(windows, test))] in src/stdlib/which/env.rs can revert to #[cfg(windows)], updating code or documentation accordingly.	❌	The diff only adds the Windows CI job; it does not modify src/stdlib/which/env.rs or any documentation/ADR to record a concrete decision about reverting #[cfg(any(windows, test))] to #[cfg(windows)]. The PR body mentions that this can be reassessed, but does not actually document or implement a conclusion.

Possibly linked issues

• Add a Windows CI job covering lint, compile, and test #518: The PR adds the Windows CI job, commands, and tooling exactly as requested in the issue, closing it.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

Summary

• Add a blocking build-test-windows CI job on windows-latest.
• Run formatting, Clippy, Whitaker/Dylint, compilation, and tests with -D warnings -Zpolonius=next.
• Configure GNU Make, Ninja, Git Bash, cargo-nextest, and the pinned nightly toolchain.
• Make Windows path handling, command execution, configuration discovery, temporary Ninja files, and test fixtures platform-safe.
• Add workflow-contract coverage for Windows CI, coverage wiring, toolchain flags, and cache configuration.
• Preserve #[cfg(any(windows, test))] for PATHEXT logic and document the rationale.
• Improve configuration-layer de-duplication, canonicalization, diagnostics, and related property and regression tests.
• Update developer and user documentation, including the configuration discovery execplan.

Walkthrough

Summary

Add a Windows CI merge gate. Align platform-specific code and tests with Windows builds. Canonicalise configuration paths and remove duplicate project layers. Strengthen workflow, coverage, packaging, and toolchain contracts.

Changes

Windows CI and cross-platform support

Layer / File(s)	Summary
Platform-gated test support src/manifest/..., src/stdlib/..., test_support/..., tests/...	Restrict Unix-only imports and test modules to Unix. Add Windows fake-Ninja support and preserve shared test interfaces.
Cross-platform runtime and test paths src/stdlib/..., src/runner/..., test_support/..., tests/...	Use native path handling for command execution, cache validation, sidecar retention, temporary Ninja files, filesystem helpers, lookup tests, and Windows assertions.
Canonical configuration discovery Cargo.toml, src/cli/..., docs/users-guide.md, docs/developers-guide.md, docs/execplans/...	Use dunce path canonicalisation. De-duplicate project layers. Record bounded discovery counts and defer diagnostic emission until replay.
Windows CI pipeline and workflow contracts .github/workflows/*, tests/workflow_*.rs, tests/workflow_contracts/*, docs/developers-guide.md	Add Windows formatting, Clippy, Whitaker, and test gates. Centralise NEXTEST_VERSION. Enforce Rust flags, cache settings, coverage ordering, and Windows workflow structure.

Sequence Diagram(s)

sequenceDiagram
  participant WindowsRunner
  participant RustSetup
  participant Make
  participant TestSuite
  WindowsRunner->>RustSetup: Install pinned Rust toolchain with warnings and Polonius flags
  WindowsRunner->>Make: Run check-fmt, lint, and test through Git Bash
  Make->>TestSuite: Compile and execute Windows-specific tests
  TestSuite-->>WindowsRunner: Return blocking CI status

Loading

Suggested labels: Issue

Poem

Windows wakes, the gates align,
Rust flags glow in ordered line.
Paths resolve and layers merge,
Tests cross platforms, clean and sure.
Ninja hums; CI rings true.

🚥 Pre-merge checks | ✅ 19 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Developer Documentation	⚠️ Warning	The PR renames the discovery boundary to collect_file_layers_with_normalizer_and_trace, but both guides still name the removed API; docs/netsuke-design.md is unchanged.	Update the developer guide and design document for the normalizer and de-duplication boundary, and correct stale PR #562 references in the ExecPlan.

✅ Passed checks (19 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title accurately describes the blocking Windows CI job and references the linked issue number (#518).
Description check	✅ Passed	The description clearly explains the Windows CI job, its tooling, scope, lint posture, related fixes, and remaining validation context.
Linked Issues check	✅ Passed	The changes satisfy issue #518 by adding Windows CI gates, preserving warning enforcement, avoiding duplicated checks, and documenting PATHEXT configuration.
Out of Scope Changes check	✅ Passed	The platform fixes, workflow contracts, tests, documentation, and tooling changes directly support the Windows CI objective in issue #518.
Docstring Coverage	✅ Passed	Docstring coverage is 100.00% which is sufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 169 functions across 49 files. (4 skipped: 4 unsupported.)
Testing (Overall)	✅ Passed	Accept: tests exercise changed behaviour with concrete oracles, including Windows command output, path de-duplication, file reopening, cache rejection, retention, CLI naming, and CI contracts.
User-Facing Documentation	✅ Passed	Keep the check passing: the users' guide documents Windows path normalisation and one-layer de-duplication for equivalent configuration paths at docs/users-guide.md:992-995.
Module-Level Documentation	✅ Passed	All changed Rust modules retain //! docs. New canonicalize.rs explains its purpose and child-module relationship to fs; its nested test module is also documented.
Testing (Unit And Behavioural)	✅ Passed	Tests cover discovery de-duplication and fallback errors, Windows shell/PATHEXT/cache and runner paths, canonicalisation edge cases, and CI contracts at functional boundaries; no tests are ignored.
Testing (Property / Proof)	✅ Passed	The PR adds substantive proptest coverage for canonical path aliases and repeated diagnostic replay, plus targeted Windows cases; no new lemma or proof assumption requires exhaustive proof.
Testing (Compile-Time / Ui)	✅ Passed	Changed cfg/const surfaces are internal and compiled by the blocking Windows job; output changes have focused assertions and existing snapshots. No additional trybuild/UI test is required.
Unit Architecture	✅ Passed	Keep this change: discovery injects EnvProvider and PathNormalizer, fallible I/O returns Result, named emit methods defer side-effects, and tests verify query silence and replay without re-reading...
Domain Architecture	✅ Passed	Keep the check passing: the diff changes only CLI, stdlib, runner, test, and CI layers; no AST, IR, or graph domain module changed or references the new adapter APIs.
Observability	✅ Passed	Changed discovery emits deferred bounded layer-count diagnostics; config-load metrics cover phase outcomes and duration; command and retention changes remain under bounded tracing and metrics.
Security And Privacy	✅ Passed	Pass this check: no new credential literals or sensitive data appear; CI keeps contents: read and persist-credentials false; shell execution remains an existing documented capability.
Performance And Resource Use	✅ Passed	Changed code remains linear or depth-bounded: discovery uses a HashSet, workspace traversal stays bounded, and the added ancestor metadata scan is confined to test_support; no unbounded cache or ho...
Concurrency And State	✅ Passed	The diff adds no shared mutable state, async tasks, or lock protocol; discovery uses local owned de-duplication and preserves order, with duplicate and TempPath lifetime tests added.
Architectural Complexity And Maintainability	✅ Passed	The diff adds scoped discovery deduplication, a platform command helper, and a fixture filesystem helper with explicit seams, bounded contracts, tests, and documented ownership; no speculative arch...
Rust Compiler Lint Integrity	✅ Passed	Keep the change: the diff adds no broad allow attributes or lint relaxations; new expects are item-level, and changed helpers have real callers. Ownership conversions are bounded and justified by t...

✨ Finishing Touches 💡 1

🛠️ Fix failing CI checks 💡

• Create stacked PR
• Commit on current branch

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch issue-518-add-a-windows-ci-job-covering-lint-compile-and-test

---

_{Comment @coderabbitai help to get the list of available commands.}

[leynos]

@coderabbitai Have the following failed checks now been resolved?

If further work is required, please provide an AI agent prompt for the remaining work to be done to address these failures.

Do not treat warnings as optional or aspirational. Where a change is out of scope for this PR, propose a GitHub issue unless one exists already. (Treat o11y, code safety, documentation and validation coverage as in scope).

#518 Assess and record whether #[cfg(any(windows, test))] in src/stdlib/which/env.rs can revert to #[cfg(windows)], updating code or documentation accordingly. ❌ The diff only adds the Windows CI job; it does not modify src/stdlib/which/env.rs or any documentation/ADR to record a concrete decision about reverting #[cfg(any(windows, test))] to #[cfg(windows)]. The PR body mentions that this can be reassessed, but does not actually document or implement a conclusion.

[sourcery-ai]

Sorry @leynos, you have reached your weekly rate limit of 500000 diff characters.

Please try again later or upgrade to continue using Sourcery

[codescene-access]

No quality gates enabled for this code.