@delegance/claude-autopilot 5.2.2 → 6.2.2

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

@@ -0,0 +1,23 @@
+export interface BrainstormCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    /**
+     * v6.0.3 — engine knob inputs. Same shape and precedence as scan / costs /
+     * fix (CLI > env > config > built-in default off in v6.0.x). The CLI
+     * dispatcher wires `cliEngine` from `--engine` / `--no-engine`;
+     * `envEngine` from `process.env.CLAUDE_AUTOPILOT_ENGINE`. An absent CLI
+     * flag + absent env value falls through to the loaded config and then to
+     * the built-in default.
+     */
+    cliEngine?: boolean;
+    envEngine?: string;
+    /**
+     * Test-only seam — when true, the phase body returns its result without
+     * printing the advisory banner. Lets engine-smoke tests assert the
+     * `state.json` + `events.ndjson` lifecycle without polluting stdout.
+     * Production callers (the CLI dispatcher) MUST NOT pass this.
+     */
+    __silent?: boolean;
+}
+export declare function runBrainstorm(options?: BrainstormCommandOptions): Promise<number>;
+//# sourceMappingURL=brainstorm.d.ts.map

package/dist/src/cli/brainstorm.js

@@ -0,0 +1,131 @@
+// src/cli/brainstorm.ts
+//
+// v6.0.3 — wrap the `brainstorm` pipeline phase through `runPhase`.
+//
+// `brainstorm` is the entry point of the autopilot pipeline. It is implemented
+// primarily as a Claude Code skill (`/brainstorm` → `superpowers:brainstorming`),
+// not as a standalone CLI subcommand. The CLI verb that ships in this binary is
+// an advisory shim: it points the user at the Claude Code skill and the next
+// pipeline verbs. There is no LLM call in the CLI verb body, and no provider
+// side effects. The pure-LLM design dialogue happens in Claude Code; the spec
+// markdown produced there lands at `docs/superpowers/specs/<slug>.md` (a local
+// file write, not a platform-side-effect-free remote write — the recipe treats
+// local file writes as acceptable inside the phase body, identical precedent to
+// `fix.ts` editing local source files).
+//
+// Idempotency / side effects (deviation note vs. spec table):
+//   - The spec table at docs/specs/v6-run-state-engine.md says
+//     `idempotent: no` for `brainstorm` because re-running produces NEW LLM
+//     content each invocation. The recipe table at
+//     docs/v6/wrapping-pipeline-phases.md previously echoed that. v6.0.3
+//     declares `idempotent: true` to match the engine's actual semantics
+//     ("safe to retry without reconciliation"): the CLI verb itself is a
+//     printed advisory message that is byte-for-byte identical on every
+//     invocation, has no externalRefs to reconcile, and no provider state
+//     to roll back. The engine's idempotency check is "safe to replay,"
+//     not "produces byte-identical output." See the recipe section 2:
+//     `idempotent: true → phase output depends only on its input + project
+//     state, and re-running gives the same answer.` That holds here.
+//   - `hasSideEffects: false` — the CLI verb prints to stdout. No provider
+//     calls, no git push, no PR creation, no remote API write. Identical
+//     to costs.
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { loadConfig } from "../core/config/loader.js";
+import { runPhaseWithLifecycle } from "../core/run-state/run-phase-with-lifecycle.js";
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    cyan: '\x1b[36m', red: '\x1b[31m',
+};
+const fmt = (c, t) => `${C[c]}${t}${C.reset}`;
+export async function runBrainstorm(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
+    let config = { configVersion: 1 };
+    if (fs.existsSync(configPath)) {
+        const loaded = await loadConfig(configPath);
+        if (loaded)
+            config = loaded;
+    }
+    const brainstormInput = { cwd, silent: options.__silent === true };
+    // The wrapped phase body. Pure: reads no files, makes no provider calls.
+    // Engine-off callers invoke `executeBrainstormPhase()` directly;
+    // engine-on callers route through `runPhase()`.
+    const phase = {
+        name: 'brainstorm',
+        // Pure-LLM design dialogue happens in the Claude Code skill, not here.
+        // The CLI verb is an advisory print with no externalRefs to reconcile
+        // and no provider state to roll back. Safe to retry. (Deviation from
+        // the spec table noted at the top of the file.)
+        idempotent: true,
+        // No provider calls, no git push, no PR creation. Identical to costs.
+        hasSideEffects: false,
+        run: async (input) => executeBrainstormPhase(input),
+    };
+    // v6.0.6 — lifecycle wiring lives in `runPhaseWithLifecycle`. The helper
+    // owns the engine-on/engine-off branch and the failure banner.
+    let output;
+    try {
+        const result = await runPhaseWithLifecycle({
+            cwd,
+            phase,
+            input: brainstormInput,
+            config,
+            cliEngine: options.cliEngine,
+            envEngine: options.envEngine,
+            runEngineOff: () => executeBrainstormPhase(brainstormInput),
+        });
+        output = result.output;
+    }
+    catch {
+        // Helper already printed the failure banner + emitted run.complete
+        // failed + refreshed state.json + released the lock.
+        return 1;
+    }
+    return renderBrainstormOutput(output, brainstormInput);
+}
+// ---------------------------------------------------------------------------
+// Phase body — produce the advisory payload. Pure: no provider calls. By
+// default does NOT print to stdout (the renderer handles that) so the engine
+// path's idempotency isn't coupled to console output. Returns a
+// JSON-serializable BrainstormOutput so the engine can persist it as
+// `result` on the phase snapshot.
+// ---------------------------------------------------------------------------
+async function executeBrainstormPhase(_input) {
+    return {
+        kind: 'advisory',
+        nextActions: [
+            'Invoke /brainstorm from Claude Code for interactive spec writing',
+            'Then /autopilot to run the full pipeline from an approved spec',
+        ],
+    };
+}
+// ---------------------------------------------------------------------------
+// Render — translate BrainstormOutput back to the legacy stdout advisory +
+// exit code. Lives outside the wrapped phase because it's pure presentation;
+// doing the rendering inside the phase would couple the engine path's
+// idempotency to console output.
+// ---------------------------------------------------------------------------
+function renderBrainstormOutput(_output, input) {
+    if (input.silent)
+        return 0;
+    console.log(`
+${fmt('bold', '[brainstorm]')} The pipeline entry point is a Claude Code skill, not a CLI subcommand.
+
+Invoke it from Claude Code:
+
+  ${fmt('cyan', '/brainstorm')}                         Interactive spec writing
+  ${fmt('cyan', '/autopilot')}                          Full pipeline from an approved spec
+  ${fmt('cyan', '/migrate')}                            Database migration phase (stack-dependent)
+
+From the terminal, the CLI subset exposes only the individual review-phase subcommands:
+
+  ${fmt('cyan', 'claude-autopilot run --base main')}    Just the review phase
+  ${fmt('cyan', 'claude-autopilot doctor')}             Check prerequisites (incl. superpowers plugin)
+  ${fmt('cyan', 'claude-autopilot migrate-v4')}         Codemod for v4 → v5 repo migration (not a pipeline phase)
+
+Full pipeline docs: https://github.com/axledbetter/claude-autopilot#the-pipeline-phase-by-phase
+`);
+    return 0;
+}
+//# sourceMappingURL=brainstorm.js.map

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

@@ -1,2 +1,16 @@
-export declare function runCosts(cwd?: string): Promise<number>;
+export interface CostsCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    /**
+     * v6.0.2 — engine knob inputs. Same shape and precedence as scan
+     * (CLI > env > config > built-in default off in v6.0.x). The CLI dispatcher
+     * wires `cliEngine` from `--engine` / `--no-engine`; `envEngine` from
+     * `process.env.CLAUDE_AUTOPILOT_ENGINE`. An absent CLI flag + absent env
+     * value falls through to the loaded config and then to the built-in
+     * default.
+     */
+    cliEngine?: boolean;
+    envEngine?: string;
+}
+export declare function runCosts(cwdOrOptions?: string | CostsCommandOptions): Promise<number>;
 //# sourceMappingURL=costs.d.ts.map

package/dist/src/cli/costs.js

@@ -1,7 +1,11 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
 import { readCostLog } from "../core/persist/cost-log.js";
+import { loadConfig } from "../core/config/loader.js";
+import { runPhaseWithLifecycle } from "../core/run-state/run-phase-with-lifecycle.js";
 const C = {
     reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-    green: '\x1b[32m', yellow: '\x1b[33m', cyan: '\x1b[36m',
+    green: '\x1b[32m', yellow: '\x1b[33m', cyan: '\x1b[36m', red: '\x1b[31m',
 };
 const fmt = (c, t) => `${C[c]}${t}${C.reset}`;
 function formatDate(iso) {
@@ -19,13 +23,69 @@ function fmtUSD(n) {
 function fmtTokens(n) {
     return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
 }
-export async function runCosts(cwd = process.cwd()) {
-    const log = readCostLog(cwd);
-    if (log.length === 0) {
-        console.log(fmt('yellow', `[costs] No run history found in ${cwd} — run \`guardrail run\` first.`));
-        console.log(fmt('dim', `        (Costs are scoped per-project. \`cd\` to the project before checking.)`));
-        return 0;
+export async function runCosts(cwdOrOptions = {}) {
+    // Back-compat — early callers (tests, MCP) pass a bare `cwd: string`. The
+    // tests/costs.test.ts harness drives this shape directly. Promote both
+    // forms into a single options struct so the rest of the function can treat
+    // it uniformly.
+    const options = typeof cwdOrOptions === 'string'
+        ? { cwd: cwdOrOptions }
+        : cwdOrOptions;
+    const cwd = options.cwd ?? process.cwd();
+    const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
+    let config = { configVersion: 1 };
+    if (fs.existsSync(configPath)) {
+        const loaded = await loadConfig(configPath);
+        if (loaded)
+            config = loaded;
+    }
+    const costsInput = { cwd };
+    // The wrapped phase body — pure read of the cost ledger + summary build.
+    // Extracted into a RunPhase so the engine-on path and the engine-off path
+    // share the exact same logic. Engine-off callers invoke this directly via
+    // `executeCostsPhase()`; engine-on callers route through `runPhase()`.
+    const phase = {
+        name: 'costs',
+        // Cost summary is a pure read of `.guardrail-cache/costs.jsonl` — re-running
+        // produces identical output for identical ledger contents. Always safe to
+        // retry.
+        idempotent: true,
+        // No provider calls, no git push, no PR comment, no file writes (the
+        // ledger is read-only on this path; the writer is `appendCostLog` called
+        // by other verbs). Replays are safe.
+        hasSideEffects: false,
+        run: async (input) => executeCostsPhase(input),
+    };
+    // v6.0.6 — lifecycle wiring lives in `runPhaseWithLifecycle`. The helper
+    // owns the engine-on/engine-off branch and the failure banner; the caller
+    // just supplies the phase, the input, and the engine-off escape hatch.
+    let output;
+    try {
+        const result = await runPhaseWithLifecycle({
+            cwd,
+            phase,
+            input: costsInput,
+            config,
+            cliEngine: options.cliEngine,
+            envEngine: options.envEngine,
+            runEngineOff: () => executeCostsPhase(costsInput),
+        });
+        output = result.output;
+    }
+    catch {
+        // Helper already printed the failure banner + emitted run.complete
+        // failed + refreshed state.json + released the lock.
+        return 1;
     }
+    return renderCostsOutput(output, costsInput);
+}
+// ---------------------------------------------------------------------------
+// Phase body — read the cost ledger and assemble the summary. Pure: no
+// console output, no exit codes. Returns a JSON-serializable CostsOutput so
+// the engine can persist it as `result` on the phase snapshot.
+// ---------------------------------------------------------------------------
+async function executeCostsPhase(input) {
+    const log = readCostLog(input.cwd);
     // 7-day window
     const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
     const recent = log.filter(e => new Date(e.timestamp).getTime() >= sevenDaysAgo);
@@ -34,12 +94,41 @@ export async function runCosts(cwd = process.cwd()) {
     const totalInput = log.reduce((s, e) => s + e.inputTokens, 0);
     const totalOutput = log.reduce((s, e) => s + e.outputTokens, 0);
     const recentCost = recent.reduce((s, e) => s + e.costUSD, 0);
+    return {
+        entryCount: log.length,
+        totals: {
+            runs: log.length,
+            inputTokens: totalInput,
+            outputTokens: totalOutput,
+            costUSD: totalCost,
+        },
+        recent: {
+            runs: recent.length,
+            costUSD: recentCost,
+        },
+        last10,
+    };
+}
+// ---------------------------------------------------------------------------
+// Render — translate CostsOutput back to the legacy stdout summary + exit
+// code. Lives outside the wrapped phase because it's pure presentation;
+// doing the rendering inside the phase would couple the engine path's
+// idempotency to console output.
+// ---------------------------------------------------------------------------
+function renderCostsOutput(output, input) {
+    const { cwd } = input;
+    const { entryCount, totals, recent, last10 } = output;
+    if (entryCount === 0) {
+        console.log(fmt('yellow', `[costs] No run history found in ${cwd} — run \`guardrail run\` first.`));
+        console.log(fmt('dim', `        (Costs are scoped per-project. \`cd\` to the project before checking.)`));
+        return 0;
+    }
     console.log(`\n${fmt('bold', '[costs]')} ${fmt('dim', cwd)}\n`);
     // Summary row
     console.log(fmt('bold', 'Summary'));
-    console.log(`  All-time runs:   ${log.length}`);
-    console.log(`  All-time cost:   ${fmtUSD(totalCost)}  (${fmtTokens(totalInput)} in / ${fmtTokens(totalOutput)} out)`);
-    console.log(`  Last 7 days:     ${fmtUSD(recentCost)}  (${recent.length} run${recent.length !== 1 ? 's' : ''})`);
+    console.log(`  All-time runs:   ${totals.runs}`);
+    console.log(`  All-time cost:   ${fmtUSD(totals.costUSD)}  (${fmtTokens(totals.inputTokens)} in / ${fmtTokens(totals.outputTokens)} out)`);
+    console.log(`  Last 7 days:     ${fmtUSD(recent.costUSD)}  (${recent.runs} run${recent.runs !== 1 ? 's' : ''})`);
     console.log(fmt('dim', `  (per-project — scoped to ${cwd}/.guardrail-cache/costs.jsonl)`));
     console.log('');
     // Last 10 runs table

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

@@ -0,0 +1,71 @@
+import type { DeployAdapter, DeployConfig } from '../adapters/deploy/types.ts';
+export interface RunDeployOptions {
+    configPath?: string;
+    /** When set, overrides `deploy.adapter` from config. */
+    adapterOverride?: 'vercel' | 'fly' | 'render' | 'generic';
+    ref?: string;
+    commitSha?: string;
+    cwd?: string;
+    /** Phase 2 — when true, subscribe to streamLogs() and pipe to stderr. */
+    watch?: boolean;
+    /**
+     * Test seam — allows injecting a fake DeployAdapter without going through
+     * the real factory (which requires VERCEL_TOKEN etc.). Production callers
+     * MUST NOT set this.
+     */
+    adapterFactory?: (config: DeployConfig) => DeployAdapter;
+    /**
+     * Test seam — injected `fetch` implementation for the post-deploy health
+     * check. Defaults to `globalThis.fetch`.
+     */
+    fetchImpl?: typeof fetch;
+    /**
+     * Test seam — injected sleep function used between health-check retries.
+     * Defaults to `setTimeout`-based sleep. Pass `async () => {}` from tests.
+     */
+    sleepImpl?: (ms: number) => Promise<void>;
+    /** GitHub PR number — when set, post upserting deploy summary comment. */
+    pr?: number;
+    /**
+     * Test seam — injected `gh` CLI runner. Receives argv plus an optional
+     * stdin `body` (passed via `gh ... --body-file -`). Returns stdout.
+     * Defaults to `core/shell.runSafe`.
+     */
+    ghImpl?: (args: string[], opts?: {
+        body?: string;
+        cwd?: string;
+    }) => string;
+}
+export declare function runDeploy(opts: RunDeployOptions): Promise<number>;
+export interface RunDeployRollbackOptions {
+    configPath?: string;
+    adapterOverride?: 'vercel' | 'fly' | 'render' | 'generic';
+    /** Specific deploy ID to roll back to. When omitted, the previous prod deploy is used. */
+    to?: string;
+    cwd?: string;
+    /** Test seam — same contract as `RunDeployOptions.adapterFactory`. */
+    adapterFactory?: (config: DeployConfig) => DeployAdapter;
+}
+export interface RunDeployStatusOptions {
+    configPath?: string;
+    adapterOverride?: 'vercel' | 'fly' | 'render' | 'generic';
+    cwd?: string;
+    adapterFactory?: (config: DeployConfig) => DeployAdapter;
+}
+/**
+ * Handle `claude-autopilot deploy rollback [--to <id>]`.
+ *
+ * Returns process exit code (0 on success, 1 on failure). Failure modes:
+ * - Adapter doesn't implement rollback (e.g. generic adapter).
+ * - No previous prod deploy exists when `--to` is omitted.
+ * - Auth / network / API error (surfaced via formatErr).
+ */
+export declare function runDeployRollback(opts: RunDeployRollbackOptions): Promise<number>;
+/**
+ * Handle `claude-autopilot deploy status`. Lists the current production
+ * deploy plus the last 5 builds (newest-first), pulling from the adapter's
+ * `listDeployments` capability. Adapters that don't expose this method
+ * (e.g. the generic shell adapter) get a clear error and exit 1.
+ */
+export declare function runDeployStatus(opts: RunDeployStatusOptions): Promise<number>;
+//# sourceMappingURL=deploy.d.ts.map