@delegance/claude-autopilot 7.5.0 → 7.7.0

package/CHANGELOG.md

@@ -2,6 +2,101 @@
 
 - v5.6 Phase 7 (docs reconciliation) — pending.
 
+## 7.7.0 (2026-05-11)
+
+**v7.7.0 — Rust scaffold support.** Minor release. Promotes Rust from
+"detected-but-unsupported" (exit 3 in v7.4–v7.6) to a first-class
+scaffold target, matching the Node + Python + FastAPI + Go shape.
+
+**New:** `claude-autopilot scaffold --from-spec <spec.md> --stack rust`
+(or auto-detected when the spec's `## Files` section lists `Cargo.toml`,
+`src/main.rs`, or `src/lib.rs`).
+
+**Lib-vs-bin fork.** Rust adds a fork the Go scaffolder doesn't need:
+
+- spec lists ONLY `src/lib.rs` (no main.rs) → **library crate**
+  (`src/lib.rs` with a public `hello()` + inline `#[cfg(test)] mod tests`,
+  Cargo.lock added to `.gitignore`)
+- spec lists `src/main.rs` (with or without lib.rs) → **binary crate**
+  (`src/main.rs` with `println!` + `tests/integration_test.rs` smoke
+  test, Cargo.lock NOT in `.gitignore`)
+- spec lists BOTH → **mixed mode** (both targets generated; Cargo.lock
+  excluded since the binary target wins per Cargo's documented convention)
+- spec hints neither → defaults to binary (matches `cargo init` default)
+
+**Cargo.lock heuristic.** Library-only crates omit `Cargo.lock` from the
+commit per Cargo docs; binary + mixed crates commit it. The Rust
+scaffolder's `.gitignore` augmentation reflects this — `target/` is
+always added; `Cargo.lock` is added only when the spec resolves to
+library-only.
+
+**Crate name normalization.** Cargo identifiers are `[a-z0-9_]` only and
+must not start with a digit. The scaffolder lowercases `basename(cwd)`,
+replaces any non-allowed char with `_`, collapses underscore runs, and
+prefixes `_` when the result starts with a digit. Examples: `my-pkg-2`
+→ `my_pkg_2`, `2cool` → `_2cool`, `My App` → `my_app`, `foo.bar` →
+`foo_bar`.
+
+**Never overwrites.** `Cargo.toml`, `src/main.rs`, `src/lib.rs`, and
+`tests/integration_test.rs` are preserved if they already exist — matches
+the Go + Python scaffolder pattern.
+
+**Polyglot detection.** `detectStack()` now includes Rust signals
+(`Cargo.toml` / `src/main.rs` / `src/lib.rs`) in the polyglot count. So
+e.g. `package.json` + `Cargo.toml` together correctly fail-loud with
+`polyglot spec — pass --stack to disambiguate` instead of silently
+picking one.
+
+**`--list-stacks`** now shows Rust under Supported and drops it from
+Recognized-but-unsupported. Ruby remains the lone detection-only stack
+(would detect via `Gemfile`).
+
+## 7.6.0 (2026-05-10)
+
+**v7.6.0 — Go scaffold support.** Minor release. Promotes Go from
+"detected-but-unsupported" (exit 3 in v7.4/v7.5) to a first-class
+scaffold target, matching the Node + Python + FastAPI shape.
+
+**New:** `claude-autopilot scaffold --from-spec <spec.md> --stack go`
+(or auto-detected when the spec's `## Files` section lists `go.mod`
+or `main.go`).
+
+Generates for a basic spec:
+
+- `go.mod` — `module <basename(cwd)>` + `go 1.22`, with an inline
+  comment documenting that the module path is the local-scaffold
+  default and should be replaced with the full hosted path
+  (e.g. `github.com/<user>/<name>`) before publishing.
+- `main.go` — `package main` + Hello world (skipped when the spec
+  uses a `cmd/<name>/main.go` layout).
+- `main_test.go` — `TestSmoke` stub for table-driven tests.
+- `.gitignore` — idempotent augmentation: appends `vendor/`,
+  `*.exe`, `*.test` if not already present.
+
+**Name normalization.** `basename(cwd)` lowercased, whitespace
+collapsed to `-`. Dots + hyphens preserved (valid Go module path
+chars). Path-invalid characters (`/`, `\`, control bytes) reject
+with a clear error.
+
+**Never overwrites.** `go.mod`, `main.go`, `main_test.go`, and
+existing `.gitignore` entries are preserved — matches the Python
+scaffolder pattern.
+
+**Polyglot detection (codex CRITICAL pass-1).** `detectStack()` now
+scans `## Files` for ALL supported stack signals (Node, Python, Go)
+and exits 3 with `polyglot spec — pass --stack to disambiguate` when
+more than one supported stack is present. Previously the check was
+Node-vs-Python only; v7.6 closes the gap so e.g. `package.json` +
+`go.mod` together correctly fail-loud instead of silently picking one.
+
+**`--list-stacks`** now shows Go under Supported and drops it from
+Recognized-but-unsupported. Rust + Ruby remain detection-only; the
+Rust scaffolder is deferred to **v7.7.0** (out of scope here).
+
+**Rust deferred.** `Cargo.toml` still exits 3 ("rust detected but
+not supported until v7.7"). Targeted for v7.7.0 alongside the same
+shape (Cargo.toml + `src/main.rs` + a smoke test).
+
 ## 7.5.0 (2026-05-10)
 
 **v7.5.0 — route-sensitivity-tiered membership revocation.** Minor

package/dist/src/cli/help-text.js

@@ -28,7 +28,7 @@ export const HELP_GROUPS = [
         verbs: [
             { verb: 'init', summary: 'Scaffold guardrail.config.yaml + auto-detect migrate stack (writes .autopilot/stack.md)' },
             { verb: 'setup', summary: 'Auto-detect stack, write config, install pre-push hook' },
-            { verb: 'scaffold', summary: 'Scaffold project skeleton from a spec markdown (--from-spec <path> [--stack node|python|fastapi])' },
+            { verb: 'scaffold', summary: 'Scaffold project skeleton from a spec markdown (--from-spec <path> [--stack node|python|fastapi|go|rust])' },
             { verb: 'autopilot', summary: 'Multi-phase orchestrator — run scan → spec → plan → implement under one runId (v6.2.0)' },
             { verb: 'brainstorm', summary: 'Pipeline entry point (Claude Code skill — see /brainstorm)' },
             { verb: 'spec', summary: 'Spec-writing pointer (Claude Code skill — see /brainstorm)' },

package/dist/src/cli/index.js

@@ -934,6 +934,8 @@ switch (subcommand) {
     case 'scaffold': {
         // v7.2.0 — `claude-autopilot scaffold --from-spec <path>`
         // v7.4.0 — `--stack <node|python|fastapi>` + `--list-stacks`.
+        // v7.6.0 — `--stack go`.
+        // v7.7.0 — `--stack rust`.
         if (boolFlag('list-stacks')) {
             const { printStackList } = await import("./scaffold.js");
             printStackList();
@@ -942,8 +944,8 @@ switch (subcommand) {
         const fromSpec = flag('from-spec');
         const dryRun = boolFlag('dry-run');
         const stackArg = flag('stack');
-        if (stackArg && !['node', 'python', 'fastapi'].includes(stackArg)) {
-            console.error(`\x1b[31m[claude-autopilot] --stack "${stackArg}" not recognized — supported: node, python, fastapi\x1b[0m`);
+        if (stackArg && !['node', 'python', 'fastapi', 'go', 'rust'].includes(stackArg)) {
+            console.error(`\x1b[31m[claude-autopilot] --stack "${stackArg}" not recognized — supported: node, python, fastapi, go, rust\x1b[0m`);
             console.error(`  See: claude-autopilot scaffold --list-stacks`);
             process.exit(3);
         }

package/dist/src/cli/scaffold/go.d.ts

@@ -0,0 +1,27 @@
+import type { ScaffoldResult, ScaffoldRunContext } from './types.ts';
+/**
+ * Normalize a basename into a valid Go module name.
+ *
+ * - lowercased
+ * - whitespace runs collapse to a single `-`
+ * - dots + hyphens preserved (Go modules allow them)
+ * - empty result falls back to `app`
+ *
+ * Throws on path-invalid characters (`/`, `\`, NUL, other control chars) —
+ * the caller is expected to surface this as a scaffold error.
+ */
+export declare function normalizeGoModuleName(raw: string): string;
+/** Build the go.mod body. Inline comment documents the local-default. */
+export declare function buildGoMod(moduleName: string): string;
+/** Build main.go body — minimal Hello world package. */
+export declare function buildMainGo(): string;
+/** Build main_test.go body — table-test friendly smoke test. */
+export declare function buildMainTestGo(): string;
+/**
+ * Augment `.gitignore` with Go-standard ignores. Idempotent: if `vendor/`
+ * already appears the second invocation leaves it alone. Creates the file
+ * if it doesn't exist.
+ */
+export declare function augmentGitignore(existing: string | null): string;
+export declare function scaffoldGo(ctx: ScaffoldRunContext): Promise<ScaffoldResult>;
+//# sourceMappingURL=go.d.ts.map

package/dist/src/cli/scaffold/go.js

@@ -0,0 +1,225 @@
+// v7.6.0 — Go scaffolder.
+//
+// Mirrors the Python scaffolder shape:
+//   - single `scaffoldGo()` exported entrypoint
+//   - pure-function helpers (name normalization, builders) for unit tests
+//   - never overwrites existing files (matches `· exists` log pattern)
+//   - tracks filesCreated / dirsCreated / filesSkippedExisting for return
+//
+// Output for a basic spec (`## Files` listing go.mod + main.go + main_test.go):
+//   - go.mod with `module <basename(cwd)>` and `go 1.22`. Inline comment
+//     documents the local-scaffold-default per codex NOTE (not a real
+//     hosted module path — users override before publishing).
+//   - main.go: package main + Hello world (only when not under cmd/<name>/)
+//   - main_test.go: smoke test
+//   - .gitignore augmentation: appends `vendor/`, `*.exe`, `*.test`
+//     idempotently — if already present, leaves them alone.
+//
+// Name normalization: lowercased basename(cwd), whitespace -> `-`. Dots and
+// hyphens preserved (Go module paths permit them). Path-invalid chars
+// (`/`, `\`, control chars) are rejected with a clear error.
+import * as fs from 'node:fs';
+import * as fsAsync from 'node:fs/promises';
+import * as path from 'node:path';
+const PASS = '\x1b[32m✓\x1b[0m';
+const SKIP = '\x1b[2m·\x1b[0m';
+const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
+/**
+ * Normalize a basename into a valid Go module name.
+ *
+ * - lowercased
+ * - whitespace runs collapse to a single `-`
+ * - dots + hyphens preserved (Go modules allow them)
+ * - empty result falls back to `app`
+ *
+ * Throws on path-invalid characters (`/`, `\`, NUL, other control chars) —
+ * the caller is expected to surface this as a scaffold error.
+ */
+export function normalizeGoModuleName(raw) {
+    // eslint-disable-next-line no-control-regex
+    if (/[\/\\\x00-\x1f]/.test(raw)) {
+        throw new Error(`invalid Go module name "${raw}" — path/control characters not allowed`);
+    }
+    const lower = raw.toLowerCase();
+    const collapsed = lower.replace(/\s+/g, '-');
+    return collapsed.length > 0 ? collapsed : 'app';
+}
+/** Build the go.mod body. Inline comment documents the local-default. */
+export function buildGoMod(moduleName) {
+    return `// NOTE: module name is the local-scaffold default (basename of cwd).
+// Replace with your full module path (e.g. github.com/<user>/${moduleName})
+// before publishing or running \`go install\`.
+module ${moduleName}
+
+go 1.22
+`;
+}
+/** Build main.go body — minimal Hello world package. */
+export function buildMainGo() {
+    return [
+        'package main',
+        '',
+        'import "fmt"',
+        '',
+        'func main() {',
+        '\tfmt.Println("Hello, world!")',
+        '}',
+        '',
+    ].join('\n');
+}
+/** Build main_test.go body — table-test friendly smoke test. */
+export function buildMainTestGo() {
+    return [
+        'package main',
+        '',
+        'import "testing"',
+        '',
+        'func TestSmoke(t *testing.T) {',
+        '\t// Smoke test scaffolded by claude-autopilot. Replace with real',
+        '\t// table-driven cases for your package under test.',
+        '}',
+        '',
+    ].join('\n');
+}
+/** Lines to append to .gitignore. Idempotent — only adds missing entries. */
+const GO_GITIGNORE_LINES = ['vendor/', '*.exe', '*.test'];
+/**
+ * Augment `.gitignore` with Go-standard ignores. Idempotent: if `vendor/`
+ * already appears the second invocation leaves it alone. Creates the file
+ * if it doesn't exist.
+ */
+export function augmentGitignore(existing) {
+    const lines = existing ? existing.split('\n') : [];
+    const present = new Set(lines.map(l => l.trim()));
+    const toAdd = GO_GITIGNORE_LINES.filter(l => !present.has(l));
+    if (toAdd.length === 0)
+        return existing ?? '';
+    const prefix = existing && !existing.endsWith('\n') ? existing + '\n' : (existing ?? '');
+    return prefix + toAdd.join('\n') + '\n';
+}
+/**
+ * True when the spec lists ONLY a `cmd/<name>/main.go` style entrypoint
+ * (no top-level main.go). In that case we skip generating the top-level
+ * main.go — the spec author intends the cmd/ layout.
+ */
+function specHasCmdMainOnly(paths) {
+    const hasTopMain = paths.includes('main.go');
+    const hasCmdMain = paths.some(p => /^cmd\/[^/]+\/main\.go$/.test(p));
+    return hasCmdMain && !hasTopMain;
+}
+export async function scaffoldGo(ctx) {
+    const { cwd, parsed, dryRun } = ctx;
+    const moduleName = normalizeGoModuleName(path.basename(cwd));
+    const filesCreated = [];
+    const filesSkippedExisting = [];
+    const dirsCreated = [];
+    // Files we generate with content rather than empty placeholders.
+    const MANAGED_FILES = new Set(['go.mod', 'main.go', 'main_test.go', '.gitignore']);
+    // 1) Create directories implied by spec paths.
+    const dirs = new Set();
+    for (const p of parsed.paths) {
+        const d = path.dirname(p);
+        if (d && d !== '.')
+            dirs.add(d);
+    }
+    for (const d of dirs) {
+        const abs = path.join(cwd, d);
+        if (fs.existsSync(abs))
+            continue;
+        if (!dryRun)
+            await fsAsync.mkdir(abs, { recursive: true });
+        dirsCreated.push(d);
+        console.log(`  ${PASS}  mkdir   ${DIM(d + '/')}`);
+    }
+    // 2) Empty-placeholder pass for spec paths we don't manage.
+    for (const p of parsed.paths) {
+        if (MANAGED_FILES.has(p))
+            continue;
+        const abs = path.join(cwd, p);
+        if (fs.existsSync(abs)) {
+            filesSkippedExisting.push(p);
+            console.log(`  ${SKIP}  exists  ${DIM(p)}`);
+            continue;
+        }
+        if (!dryRun) {
+            await fsAsync.mkdir(path.dirname(abs), { recursive: true });
+            await fsAsync.writeFile(abs, '', 'utf8');
+        }
+        filesCreated.push(p);
+        console.log(`  ${PASS}  touch   ${DIM(p)}`);
+    }
+    // 3) go.mod — never overwrite.
+    const goModAbs = path.join(cwd, 'go.mod');
+    if (fs.existsSync(goModAbs)) {
+        filesSkippedExisting.push('go.mod');
+        console.log(`  ${SKIP}  exists  ${DIM('go.mod (preserved)')}`);
+    }
+    else {
+        if (!dryRun)
+            await fsAsync.writeFile(goModAbs, buildGoMod(moduleName), 'utf8');
+        filesCreated.push('go.mod');
+        console.log(`  ${PASS}  write   ${DIM(`go.mod (module ${moduleName}, go 1.22)`)}`);
+    }
+    // 4) main.go — only if the spec doesn't push us to a cmd/<name>/ layout.
+    const cmdOnly = specHasCmdMainOnly(parsed.paths);
+    if (!cmdOnly) {
+        const mainAbs = path.join(cwd, 'main.go');
+        if (fs.existsSync(mainAbs)) {
+            filesSkippedExisting.push('main.go');
+            console.log(`  ${SKIP}  exists  ${DIM('main.go (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(mainAbs, buildMainGo(), 'utf8');
+            filesCreated.push('main.go');
+            console.log(`  ${PASS}  write   ${DIM('main.go (package main + Hello)')}`);
+        }
+    }
+    // 5) main_test.go — only when we also wrote main.go (same cmd-only guard).
+    if (!cmdOnly) {
+        const testAbs = path.join(cwd, 'main_test.go');
+        if (fs.existsSync(testAbs)) {
+            filesSkippedExisting.push('main_test.go');
+            console.log(`  ${SKIP}  exists  ${DIM('main_test.go (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(testAbs, buildMainTestGo(), 'utf8');
+            filesCreated.push('main_test.go');
+            console.log(`  ${PASS}  write   ${DIM('main_test.go (TestSmoke stub)')}`);
+        }
+    }
+    // 6) .gitignore — idempotent augmentation.
+    const giAbs = path.join(cwd, '.gitignore');
+    const existing = fs.existsSync(giAbs) ? await fsAsync.readFile(giAbs, 'utf8') : null;
+    const augmented = augmentGitignore(existing);
+    if (existing === null) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  write   ${DIM('.gitignore (vendor/, *.exe, *.test)')}`);
+    }
+    else if (augmented !== existing) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        // Treat as "augmented" — not in skipped-existing (we modified it) and
+        // not in filesCreated (we didn't create a new file). For now we count
+        // it as filesCreated since the user sees a write. Tests assert
+        // idempotence on disk content, not on this return shape.
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  augment ${DIM('.gitignore (added Go ignores)')}`);
+    }
+    else {
+        filesSkippedExisting.push('.gitignore');
+        console.log(`  ${SKIP}  exists  ${DIM('.gitignore (Go entries already present)')}`);
+    }
+    return {
+        filesCreated,
+        dirsCreated,
+        filesSkippedExisting,
+        // Node-shape fields — Go scaffolder doesn't touch package.json/tsconfig.
+        packageJsonAction: 'skipped-exists',
+        tsconfigAction: 'skipped-no-ts',
+    };
+}
+//# sourceMappingURL=go.js.map

package/dist/src/cli/scaffold/rust.d.ts

@@ -0,0 +1,38 @@
+import type { ScaffoldResult, ScaffoldRunContext } from './types.ts';
+/**
+ * Normalize a basename into a valid Cargo crate name.
+ *
+ * Cargo identifiers: `[a-z0-9_]` only, must not start with a digit.
+ *
+ * - lowercased
+ * - any char outside `[a-z0-9_]` collapses to `_`
+ * - repeated `_` runs collapse to a single `_`
+ * - if the result starts with a digit, prefix `_`
+ * - empty result falls back to `app`
+ */
+export declare function normalizeRustCrateName(raw: string): string;
+/** Build the Cargo.toml body. */
+export declare function buildCargoToml(crateName: string): string;
+/** Build src/main.rs body — minimal Hello world binary. */
+export declare function buildMainRs(): string;
+/** Build src/lib.rs body — public fn + inline tests module. */
+export declare function buildLibRs(): string;
+/** Build tests/integration_test.rs body — smoke test. */
+export declare function buildIntegrationTestRs(): string;
+/**
+ * Augment `.gitignore` with Rust-standard ignores. Idempotent.
+ *
+ * `target/` is always added. `Cargo.lock` is added ONLY when
+ * `includeCargoLock` is true (library-only crates — lockfiles aren't
+ * committed for libraries per Cargo docs). Binary crates commit
+ * Cargo.lock so we leave it out of .gitignore.
+ */
+export declare function augmentGitignore(existing: string | null, includeCargoLock: boolean): string;
+/**
+ * Classify the crate kind based on spec `## Files` paths. See the
+ * file header comment for the fork rules.
+ */
+export type CrateKind = 'binary' | 'library' | 'mixed';
+export declare function classifyCrateKind(paths: string[]): CrateKind;
+export declare function scaffoldRust(ctx: ScaffoldRunContext): Promise<ScaffoldResult>;
+//# sourceMappingURL=rust.d.ts.map

package/dist/src/cli/scaffold/rust.js

@@ -0,0 +1,281 @@
+// v7.7.0 — Rust scaffolder.
+//
+// Mirrors src/cli/scaffold/go.ts (v7.6.0) shape:
+//   - single `scaffoldRust()` exported entrypoint
+//   - pure-function helpers (name normalization, builders) for unit tests
+//   - never overwrites existing files (matches `· exists` log pattern)
+//   - tracks filesCreated / dirsCreated / filesSkippedExisting for return
+//
+// Rust adds a lib-vs-bin fork the Go scaffolder doesn't need:
+//
+//   - spec lists ONLY `src/lib.rs` (no main.rs)         → library crate
+//       Cargo.toml + src/lib.rs (public fn + #[cfg(test)] mod tests)
+//       .gitignore augmentation INCLUDES `Cargo.lock` (lockfiles are
+//       not committed for libraries — see Cargo docs).
+//
+//   - spec lists `src/main.rs` (with or without lib.rs) → binary crate
+//       Cargo.toml + src/main.rs (println!) + tests/integration_test.rs
+//       .gitignore does NOT include Cargo.lock (binaries commit it).
+//
+//   - spec lists BOTH src/main.rs AND src/lib.rs        → mixed mode
+//       Cargo.toml + main.rs + lib.rs + tests/integration_test.rs
+//       .gitignore does NOT include Cargo.lock (binary target wins).
+//
+//   - spec lists NEITHER (or no spec hint)              → default to bin
+//       Same as the `src/main.rs`-listed case. Matches `cargo init`
+//       default — `cargo init` produces a binary unless `--lib` is
+//       passed.
+//
+// Name normalization: Cargo crate identifiers are `[a-z0-9_]` only, must
+// not start with a digit. Lowercase basename(cwd), replace any non-allowed
+// char with `_`, collapse runs of `_`, prefix `_` if the result starts
+// with a digit.
+import * as fs from 'node:fs';
+import * as fsAsync from 'node:fs/promises';
+import * as path from 'node:path';
+const PASS = '\x1b[32m✓\x1b[0m';
+const SKIP = '\x1b[2m·\x1b[0m';
+const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
+/**
+ * Normalize a basename into a valid Cargo crate name.
+ *
+ * Cargo identifiers: `[a-z0-9_]` only, must not start with a digit.
+ *
+ * - lowercased
+ * - any char outside `[a-z0-9_]` collapses to `_`
+ * - repeated `_` runs collapse to a single `_`
+ * - if the result starts with a digit, prefix `_`
+ * - empty result falls back to `app`
+ */
+export function normalizeRustCrateName(raw) {
+    const lower = raw.toLowerCase();
+    // Replace any non-[a-z0-9_] character with `_`.
+    const sanitized = lower.replace(/[^a-z0-9_]+/g, '_');
+    // Collapse repeated `_` runs.
+    const collapsed = sanitized.replace(/_+/g, '_');
+    if (collapsed.length === 0)
+        return 'app';
+    // Strip leading/trailing underscores that came from leading/trailing
+    // separators, BUT preserve a leading `_` we add for digit-start cases.
+    const trimmed = collapsed.replace(/^_+|_+$/g, '');
+    const base = trimmed.length > 0 ? trimmed : 'app';
+    // Cargo crate names cannot start with a digit.
+    return /^[0-9]/.test(base) ? `_${base}` : base;
+}
+/** Build the Cargo.toml body. */
+export function buildCargoToml(crateName) {
+    return `[package]
+name = "${crateName}"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+`;
+}
+/** Build src/main.rs body — minimal Hello world binary. */
+export function buildMainRs() {
+    return `fn main() {
+    println!("Hello from {}", env!("CARGO_PKG_NAME"));
+}
+`;
+}
+/** Build src/lib.rs body — public fn + inline tests module. */
+export function buildLibRs() {
+    return `//! Library entrypoint — auto-scaffolded by claude-autopilot.
+
+pub fn hello() -> &'static str {
+    "hello"
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(hello(), "hello");
+    }
+}
+`;
+}
+/** Build tests/integration_test.rs body — smoke test. */
+export function buildIntegrationTestRs() {
+    return `#[test]
+fn smoke() {
+    assert_eq!(2 + 2, 4);
+}
+`;
+}
+/**
+ * Augment `.gitignore` with Rust-standard ignores. Idempotent.
+ *
+ * `target/` is always added. `Cargo.lock` is added ONLY when
+ * `includeCargoLock` is true (library-only crates — lockfiles aren't
+ * committed for libraries per Cargo docs). Binary crates commit
+ * Cargo.lock so we leave it out of .gitignore.
+ */
+export function augmentGitignore(existing, includeCargoLock) {
+    const toAddCandidates = includeCargoLock ? ['target/', 'Cargo.lock'] : ['target/'];
+    const lines = existing ? existing.split('\n') : [];
+    const present = new Set(lines.map(l => l.trim()));
+    const toAdd = toAddCandidates.filter(l => !present.has(l));
+    if (toAdd.length === 0)
+        return existing ?? '';
+    const prefix = existing && !existing.endsWith('\n') ? existing + '\n' : (existing ?? '');
+    return prefix + toAdd.join('\n') + '\n';
+}
+export function classifyCrateKind(paths) {
+    const hasMain = paths.includes('src/main.rs');
+    const hasLib = paths.includes('src/lib.rs');
+    if (hasMain && hasLib)
+        return 'mixed';
+    if (hasLib && !hasMain)
+        return 'library';
+    // Default: binary (covers `src/main.rs` listed AND the "neither listed"
+    // case — matches `cargo init` default behavior).
+    return 'binary';
+}
+export async function scaffoldRust(ctx) {
+    const { cwd, parsed, dryRun } = ctx;
+    const crateName = normalizeRustCrateName(path.basename(cwd));
+    const kind = classifyCrateKind(parsed.paths);
+    // Library-only crates omit Cargo.lock from git. Binary + mixed include it.
+    const isLibraryOnly = kind === 'library';
+    const filesCreated = [];
+    const filesSkippedExisting = [];
+    const dirsCreated = [];
+    // Files we generate with content rather than empty placeholders.
+    const MANAGED_FILES = new Set([
+        'Cargo.toml',
+        'src/main.rs',
+        'src/lib.rs',
+        'tests/integration_test.rs',
+        '.gitignore',
+    ]);
+    // 1) Create directories implied by spec paths.
+    const dirs = new Set();
+    for (const p of parsed.paths) {
+        const d = path.dirname(p);
+        if (d && d !== '.')
+            dirs.add(d);
+    }
+    // Ensure we'll have a src/ dir for the targets we write.
+    if (kind !== 'library')
+        dirs.add('src');
+    if (kind === 'library' || kind === 'mixed')
+        dirs.add('src');
+    // tests/ dir for binary + mixed integration tests.
+    if (kind !== 'library')
+        dirs.add('tests');
+    for (const d of dirs) {
+        const abs = path.join(cwd, d);
+        if (fs.existsSync(abs))
+            continue;
+        if (!dryRun)
+            await fsAsync.mkdir(abs, { recursive: true });
+        dirsCreated.push(d);
+        console.log(`  ${PASS}  mkdir   ${DIM(d + '/')}`);
+    }
+    // 2) Empty-placeholder pass for spec paths we don't manage.
+    for (const p of parsed.paths) {
+        if (MANAGED_FILES.has(p))
+            continue;
+        const abs = path.join(cwd, p);
+        if (fs.existsSync(abs)) {
+            filesSkippedExisting.push(p);
+            console.log(`  ${SKIP}  exists  ${DIM(p)}`);
+            continue;
+        }
+        if (!dryRun) {
+            await fsAsync.mkdir(path.dirname(abs), { recursive: true });
+            await fsAsync.writeFile(abs, '', 'utf8');
+        }
+        filesCreated.push(p);
+        console.log(`  ${PASS}  touch   ${DIM(p)}`);
+    }
+    // 3) Cargo.toml — never overwrite.
+    const cargoAbs = path.join(cwd, 'Cargo.toml');
+    if (fs.existsSync(cargoAbs)) {
+        filesSkippedExisting.push('Cargo.toml');
+        console.log(`  ${SKIP}  exists  ${DIM('Cargo.toml (preserved)')}`);
+    }
+    else {
+        if (!dryRun)
+            await fsAsync.writeFile(cargoAbs, buildCargoToml(crateName), 'utf8');
+        filesCreated.push('Cargo.toml');
+        console.log(`  ${PASS}  write   ${DIM(`Cargo.toml (name = "${crateName}", edition 2021)`)}`);
+    }
+    // 4) src/main.rs — binary + mixed modes only.
+    if (kind === 'binary' || kind === 'mixed') {
+        const mainAbs = path.join(cwd, 'src', 'main.rs');
+        if (fs.existsSync(mainAbs)) {
+            filesSkippedExisting.push('src/main.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('src/main.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(mainAbs, buildMainRs(), 'utf8');
+            filesCreated.push('src/main.rs');
+            console.log(`  ${PASS}  write   ${DIM('src/main.rs (println! Hello)')}`);
+        }
+    }
+    // 5) src/lib.rs — library + mixed modes only.
+    if (kind === 'library' || kind === 'mixed') {
+        const libAbs = path.join(cwd, 'src', 'lib.rs');
+        if (fs.existsSync(libAbs)) {
+            filesSkippedExisting.push('src/lib.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('src/lib.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(libAbs, buildLibRs(), 'utf8');
+            filesCreated.push('src/lib.rs');
+            console.log(`  ${PASS}  write   ${DIM('src/lib.rs (pub fn + #[cfg(test)] mod tests)')}`);
+        }
+    }
+    // 6) tests/integration_test.rs — binary + mixed modes only.
+    if (kind === 'binary' || kind === 'mixed') {
+        const testAbs = path.join(cwd, 'tests', 'integration_test.rs');
+        if (fs.existsSync(testAbs)) {
+            filesSkippedExisting.push('tests/integration_test.rs');
+            console.log(`  ${SKIP}  exists  ${DIM('tests/integration_test.rs (preserved)')}`);
+        }
+        else {
+            if (!dryRun)
+                await fsAsync.writeFile(testAbs, buildIntegrationTestRs(), 'utf8');
+            filesCreated.push('tests/integration_test.rs');
+            console.log(`  ${PASS}  write   ${DIM('tests/integration_test.rs (smoke test)')}`);
+        }
+    }
+    // 7) .gitignore — idempotent augmentation. Cargo.lock conditional on
+    //    library-only crates per Cargo's documented convention.
+    const giAbs = path.join(cwd, '.gitignore');
+    const existing = fs.existsSync(giAbs) ? await fsAsync.readFile(giAbs, 'utf8') : null;
+    const augmented = augmentGitignore(existing, isLibraryOnly);
+    const lockNote = isLibraryOnly ? 'target/, Cargo.lock' : 'target/';
+    if (existing === null) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  write   ${DIM(`.gitignore (${lockNote})`)}`);
+    }
+    else if (augmented !== existing) {
+        if (!dryRun)
+            await fsAsync.writeFile(giAbs, augmented, 'utf8');
+        filesCreated.push('.gitignore');
+        console.log(`  ${PASS}  augment ${DIM(`.gitignore (added Rust ignores: ${lockNote})`)}`);
+    }
+    else {
+        filesSkippedExisting.push('.gitignore');
+        console.log(`  ${SKIP}  exists  ${DIM('.gitignore (Rust entries already present)')}`);
+    }
+    return {
+        filesCreated,
+        dirsCreated,
+        filesSkippedExisting,
+        // Node-shape fields — Rust scaffolder doesn't touch package.json/tsconfig.
+        packageJsonAction: 'skipped-exists',
+        tsconfigAction: 'skipped-no-ts',
+    };
+}
+//# sourceMappingURL=rust.js.map

package/dist/src/cli/scaffold/types.d.ts

@@ -1,11 +1,14 @@
-/** Supported `--stack` values. v7.5+ will add 'go', 'rust', 'ruby'. */
-export type Stack = 'node' | 'python' | 'fastapi';
+/** Supported `--stack` values. v7.6 adds 'go'; v7.7 adds 'rust'. */
+export type Stack = 'node' | 'python' | 'fastapi' | 'go' | 'rust';
 /**
  * Stacks we can DETECT but cannot scaffold yet. Detection still warns +
- * exits 3 so the operator gets a clear "v7.5" diagnostic instead of a
+ * exits 3 so the operator gets a clear "vX.Y" diagnostic instead of a
  * silent fallback to Node, which would generate a wrong-language skeleton.
+ *
+ * v7.7 promoted Rust from this list. Ruby remains the lone unsupported
+ * stack (would detect via `Gemfile`).
  */
-export type UnsupportedStack = 'go' | 'rust' | 'ruby';
+export type UnsupportedStack = 'ruby';
 export interface ParsedFiles {
     /** Raw paths extracted from the `## Files` section bullets. */
     paths: string[];

package/dist/src/cli/scaffold.d.ts

@@ -2,7 +2,7 @@ import { buildStarterPackageJson } from './scaffold/node.ts';
 import type { ParsedFiles, ScaffoldOptions, ScaffoldResult, Stack, UnsupportedStack } from './scaffold/types.ts';
 export { buildStarterPackageJson };
 export type { ScaffoldOptions, ScaffoldResult, ParsedFiles, Stack };
-/** Valid `--stack` argument values. v7.5+ adds 'go', 'rust', 'ruby'. */
+/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7 adds 'rust'. */
 export declare const SUPPORTED_STACKS: readonly Stack[];
 /** Stacks we DETECT-but-don't-support yet. Mapped to spec exit-3 messages. */
 export declare const UNSUPPORTED_STACK_FILES: Record<UnsupportedStack, string>;

package/dist/src/cli/scaffold.js

@@ -8,6 +8,8 @@
 //            `parseSpecFiles`, `buildStarterPackageJson`, plus the
 //            `ScaffoldOptions` / `ScaffoldResult` types from here so library
 //            consumers don't break.
+//   v7.6.0 — Go promoted from unsupported to supported.
+//   v7.7.0 — Rust promoted from unsupported to supported (lib/bin fork).
 //
 // Stack detection lives in `detectStack()`. Per the spec ("Stack detection"
 // section), precedence is:
@@ -15,11 +17,13 @@
 //   2. FastAPI (path + 'fastapi' mention) — checked BEFORE generic Python so
 //      a FastAPI spec listing pyproject.toml isn't mis-classified
 //   3. Python (pyproject.toml or requirements.txt)
-//   4. Node (package.json)
-//   5. Detected-but-unsupported (go.mod / Cargo.toml / Gemfile) -> exit 3
-//   6. Fallback: Node ESM (preserves v7.2.0 default for ambiguous specs)
+//   4. Go (go.mod or main.go)
+//   5. Rust (Cargo.toml or src/main.rs or src/lib.rs)
+//   6. Node (package.json)
+//   7. Detected-but-unsupported (Gemfile) -> exit 3
+//   8. Fallback: Node ESM (preserves v7.2.0 default for ambiguous specs)
 //
-// Polyglot guard: package.json AND pyproject.toml together without --stack
+// Polyglot guard: more than one supported-stack signal listed without --stack
 // -> exit 3 with "polyglot spec — pass --stack to disambiguate".
 //
 // Exit codes:
@@ -27,24 +31,24 @@
 //   1 — spec file missing
 //   2 — spec missing `## Files` section
 //   3 (NEW v7.4.0) — `--stack` value not recognized, detected-but-unsupported
-//                    stack (Go/Rust/Ruby), or polyglot spec without --stack
+//                    stack (Ruby), or polyglot spec without --stack
 import * as fs from 'node:fs';
 import * as fsAsync from 'node:fs/promises';
 import * as path from 'node:path';
 import { scaffoldNode, buildStarterPackageJson } from "./scaffold/node.js";
 import { scaffoldPython } from "./scaffold/python.js";
+import { scaffoldGo } from "./scaffold/go.js";
+import { scaffoldRust } from "./scaffold/rust.js";
 const BOLD = (t) => `\x1b[1m${t}\x1b[0m`;
 const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
 // Re-export types + the legacy buildStarterPackageJson so `src/index.ts` and
 // the existing tests/scaffold.test.ts (which imports from this module) keep
 // compiling without changes.
 export { buildStarterPackageJson };
-/** Valid `--stack` argument values. v7.5+ adds 'go', 'rust', 'ruby'. */
-export const SUPPORTED_STACKS = ['node', 'python', 'fastapi'];
+/** Valid `--stack` argument values. v7.6 adds 'go'; v7.7 adds 'rust'. */
+export const SUPPORTED_STACKS = ['node', 'python', 'fastapi', 'go', 'rust'];
 /** Stacks we DETECT-but-don't-support yet. Mapped to spec exit-3 messages. */
 export const UNSUPPORTED_STACK_FILES = {
-    go: 'go.mod',
-    rust: 'Cargo.toml',
     ruby: 'Gemfile',
 };
 /**
@@ -215,8 +219,30 @@ export function detectStack(parsed, explicit) {
     const hasFastapiMention = parsed.packageHints.stackHint === 'fastapi';
     const hasPythonMarker = has('pyproject.toml') || has('requirements.txt');
     const hasNodeMarker = has('package.json');
-    // Polyglot guard (codex W3) — Node + Python without --stack.
-    if (hasNodeMarker && hasPythonMarker) {
+    // v7.6 — Go signal: `go.mod` OR a top-level / cmd-shaped `main.go`.
+    const hasGoMod = has('go.mod');
+    const hasMainGo = paths.some(p => p === 'main.go' || /^cmd\/[^/]+\/main\.go$/.test(p));
+    const hasGoMarker = hasGoMod || hasMainGo;
+    // v7.7 — Rust signal: `Cargo.toml` OR `src/main.rs` OR `src/lib.rs`.
+    const hasCargoToml = has('Cargo.toml');
+    const hasMainRs = has('src/main.rs');
+    const hasLibRs = has('src/lib.rs');
+    const hasRustMarker = hasCargoToml || hasMainRs || hasLibRs;
+    // v7.6 — Polyglot detection scans ALL supported stack signals at once.
+    // We collect each present stack and exit 3 if more than one supported
+    // stack is detected (e.g. Node + Go, Python + Go, Node + Python + Go).
+    // FastAPI is collapsed into Python for the polyglot count (they share
+    // pyproject.toml — not a real conflict). v7.7 adds Rust to the count.
+    const supportedSignals = [];
+    if (hasNodeMarker)
+        supportedSignals.push('node');
+    if (hasPythonMarker)
+        supportedSignals.push('python');
+    if (hasGoMarker)
+        supportedSignals.push('go');
+    if (hasRustMarker)
+        supportedSignals.push('rust');
+    if (supportedSignals.length > 1) {
         return {
             kind: 'polyglot',
             message: 'polyglot spec — pass --stack to disambiguate',
@@ -235,20 +261,26 @@ export function detectStack(parsed, explicit) {
     // Step 3: Python.
     if (hasPythonMarker)
         return { kind: 'resolved', stack: 'python' };
-    // Step 4: Node.
+    // Step 4: Go (v7.6).
+    if (hasGoMarker)
+        return { kind: 'resolved', stack: 'go' };
+    // Step 5: Rust (v7.7).
+    if (hasRustMarker)
+        return { kind: 'resolved', stack: 'rust' };
+    // Step 6: Node.
     if (hasNodeMarker)
         return { kind: 'resolved', stack: 'node' };
-    // Step 5: detected-but-unsupported (codex W2).
+    // Step 7: detected-but-unsupported (codex W2). Ruby remains; Rust + Go promoted.
     for (const [stack, file] of Object.entries(UNSUPPORTED_STACK_FILES)) {
         if (has(file)) {
             return {
                 kind: 'unsupported',
                 stack,
-                message: `${stack} detected but not supported until v7.5`,
+                message: `${stack} detected but not supported until v7.7`,
             };
         }
     }
-    // Step 6: fallback — Node ESM (preserves v7.2.0 default for ambiguous
+    // Step 7: fallback — Node ESM (preserves v7.2.0 default for ambiguous
     // specs that listed only paths with no root-marker file).
     return { kind: 'resolved', stack: 'node' };
 }
@@ -262,16 +294,18 @@ export function printStackList() {
     console.log('  node     Node 22 ESM (package.json + tsconfig.json)');
     console.log('  python   Python 3.11+ (pyproject.toml + hatchling + pytest)');
     console.log('  fastapi  Python + FastAPI (auto-includes fastapi + uvicorn[standard])');
+    console.log('  go       Go 1.22 (go.mod + main.go + main_test.go)');
+    console.log('  rust     Rust 2021 (Cargo.toml + src/{main,lib}.rs + tests/integration_test.rs)');
     console.log('');
     console.log(BOLD('Auto-detected from `## Files`:'));
     console.log('  node     when `package.json` is listed');
     console.log('  python   when `pyproject.toml` or `requirements.txt` is listed');
     console.log('  fastapi  when `main.py` is listed AND a bullet mentions `fastapi`');
+    console.log('  go       when `go.mod` or `main.go` is listed');
+    console.log('  rust     when `Cargo.toml`, `src/main.rs`, or `src/lib.rs` is listed');
     console.log('');
     console.log(BOLD('Recognized-but-unsupported (exit 3):'));
-    console.log('  go       v7.5  (would detect via go.mod)');
-    console.log('  rust     v7.5  (would detect via Cargo.toml)');
-    console.log('  ruby     v7.5+ (would detect via Gemfile)');
+    console.log('  ruby     v7.8+ (would detect via Gemfile)');
     console.log('');
 }
 export async function runScaffold(opts) {
@@ -305,34 +339,60 @@ export async function runScaffold(opts) {
     }
     const stack = detection.stack;
     console.log(`\n${BOLD('[scaffold]')} ${DIM(specAbs)} ${DIM(`(stack: ${stack})`)}\n`);
-    // codex W5 — when --stack <python|fastapi> is explicit and the spec
-    // ALSO lists Node files, warn + filter them out so the Python
-    // scaffolder doesn't try to touch them.
+    // codex W5 — when an explicit --stack is passed against a polyglot spec,
+    // strip the OTHER stack's marker files so the chosen scaffolder doesn't
+    // touch them as empty placeholders. v7.6 extends this to Go; v7.7 to Rust.
     let ignoredOtherStackFiles;
     let parsedForStack = parsed;
+    const NODE_FILES = new Set(['package.json', 'tsconfig.json']);
+    const PYTHON_FILES = new Set(['pyproject.toml', 'requirements.txt']);
+    const GO_FILES = new Set(['go.mod']);
+    const RUST_FILES = new Set(['Cargo.toml']);
     if (opts.stack && (stack === 'python' || stack === 'fastapi')) {
-        const NODE_FILES = new Set(['package.json', 'tsconfig.json']);
-        const ignored = parsed.paths.filter(p => NODE_FILES.has(p));
+        const toIgnore = new Set([...NODE_FILES, ...GO_FILES, ...RUST_FILES]);
+        const ignored = parsed.paths.filter(p => toIgnore.has(p));
         if (ignored.length > 0) {
             ignoredOtherStackFiles = ignored;
-            console.log(`  ${DIM(`! ignoring Node files (--stack ${stack}): ${ignored.join(', ')}`)}`);
+            console.log(`  ${DIM(`! ignoring non-Python files (--stack ${stack}): ${ignored.join(', ')}`)}`);
             parsedForStack = {
                 ...parsed,
-                paths: parsed.paths.filter(p => !NODE_FILES.has(p)),
+                paths: parsed.paths.filter(p => !toIgnore.has(p)),
             };
         }
     }
     else if (opts.stack === 'node') {
-        // Symmetric: when --stack node is forced and the spec also lists
-        // Python markers, drop them so we don't touch them as placeholders.
-        const PYTHON_FILES = new Set(['pyproject.toml', 'requirements.txt']);
-        const ignored = parsed.paths.filter(p => PYTHON_FILES.has(p));
+        const toIgnore = new Set([...PYTHON_FILES, ...GO_FILES, ...RUST_FILES]);
+        const ignored = parsed.paths.filter(p => toIgnore.has(p));
+        if (ignored.length > 0) {
+            ignoredOtherStackFiles = ignored;
+            console.log(`  ${DIM(`! ignoring non-Node files (--stack node): ${ignored.join(', ')}`)}`);
+            parsedForStack = {
+                ...parsed,
+                paths: parsed.paths.filter(p => !toIgnore.has(p)),
+            };
+        }
+    }
+    else if (opts.stack === 'go') {
+        const toIgnore = new Set([...NODE_FILES, ...PYTHON_FILES, ...RUST_FILES]);
+        const ignored = parsed.paths.filter(p => toIgnore.has(p));
         if (ignored.length > 0) {
             ignoredOtherStackFiles = ignored;
-            console.log(`  ${DIM(`! ignoring Python files (--stack node): ${ignored.join(', ')}`)}`);
+            console.log(`  ${DIM(`! ignoring non-Go files (--stack go): ${ignored.join(', ')}`)}`);
             parsedForStack = {
                 ...parsed,
-                paths: parsed.paths.filter(p => !PYTHON_FILES.has(p)),
+                paths: parsed.paths.filter(p => !toIgnore.has(p)),
+            };
+        }
+    }
+    else if (opts.stack === 'rust') {
+        const toIgnore = new Set([...NODE_FILES, ...PYTHON_FILES, ...GO_FILES]);
+        const ignored = parsed.paths.filter(p => toIgnore.has(p));
+        if (ignored.length > 0) {
+            ignoredOtherStackFiles = ignored;
+            console.log(`  ${DIM(`! ignoring non-Rust files (--stack rust): ${ignored.join(', ')}`)}`);
+            parsedForStack = {
+                ...parsed,
+                paths: parsed.paths.filter(p => !toIgnore.has(p)),
             };
         }
     }
@@ -344,6 +404,12 @@ export async function runScaffold(opts) {
     else if (stack === 'fastapi') {
         result = await scaffoldPython(ctx, { isFastapi: true });
     }
+    else if (stack === 'go') {
+        result = await scaffoldGo(ctx);
+    }
+    else if (stack === 'rust') {
+        result = await scaffoldRust(ctx);
+    }
     else {
         result = await scaffoldNode(ctx);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "7.5.0",
+  "version": "7.7.0",
   "type": "module",
   "publishConfig": {
     "tag": "next"