@delegance/claude-autopilot 1.0.0-alpha.7 → 1.0.0-alpha.8

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.0.0-alpha.8
+
+### Added
+
+- **`autopilot autoregress`** — `autoregress run|diff|update|generate` now a first-class `autopilot` subcommand (no more raw `npx tsx scripts/autoregress.ts`)
+- **GitHub Actions CI** — `.github/workflows/ci.yml` runs typecheck + tests on every PR; auto-publishes to npm on `v*` tags
+- **README rewrite** — full feature documentation covering all alphas (all commands, config, GitHub Actions, snapshot regression, architecture)
+
 ## 1.0.0-alpha.7
 
 ### Added

package/README.md

@@ -1,58 +1,159 @@
-# claude-autopilot
+# @delegance/claude-autopilot
 
-End-to-end Claude Code pipeline: approved spec → plan → worktree → implementation → migrations → validation → PR → review engine → review-bot triage.
+Automated code review pipeline for Claude Code. Runs static rules, an optional LLM review engine, and impact-aware snapshot regression tests — outputs SARIF for GitHub Code Scanning, inline PR annotations, and a pre-push hook for local enforcement.
 
-**Status: v1.0.0-alpha.1** — core architecture in place, ported adapters (codex, github, supabase, cursor), 1 preset (nextjs-supabase), 32 passing tests. API may change through alpha.
+## Install
 
-Full design spec: `docs/superpowers/specs/2026-04-20-claude-autopilot-v1-design.md`
-Implementation plans: `docs/superpowers/plans/`
+```bash
+npm install --save-dev @delegance/claude-autopilot@alpha
+```
 
-## Changes in v1.0 (alpha.1)
+Requires Node 22+.
 
-- Four pluggable integration points (ReviewEngine, VcsHost, MigrationRunner, ReviewBotParser) with shared `AdapterBase`
-- YAML config (`autopilot.config.yaml`) replaces `.autopilot/stack.md`
-- Unified `Finding` type across validate + review-bot, with separate `TriageRecord[]` / `FixAttempt[]` history
-- Merged static-rules phase with global re-check after autofix
-- `AutopilotError` taxonomy with per-code retry policy
-- `apiVersion` + `getCapabilities()` on every adapter
-- Real tests phase — runs `testCommand` from config, emits critical finding on failure
-- NDJSON event log with secret redaction
+## Quick Start
 
-## Prerequisites
+```bash
+# Scaffold config
+npx autopilot init
 
-- Node 22+
-- `gh` CLI authenticated
-- `OPENAI_API_KEY` in `.env.local`
+# Run on changed files
+npx autopilot run
 
-## Install
+# Watch mode (re-runs on every file save)
+npx autopilot watch
+
+# Install pre-push hook
+npx autopilot hook install
+```
+
+## Commands
+
+### `autopilot run`
+
+Runs the pipeline on git-changed files vs the base ref.
 
 ```bash
-npm install --save-dev @delegance/claude-autopilot@alpha
+npx autopilot run                        # diff against HEAD~1
+npx autopilot run --base main            # diff against main
+npx autopilot run --files src/foo.ts     # explicit file list
+npx autopilot run --format sarif --output results.sarif
+npx autopilot run --dry-run              # show what would run, no execution
+```
+
+### `autopilot watch`
+
+Debounced re-run on every file save.
+
+```bash
+npx autopilot watch
+npx autopilot watch --debounce 500
 ```
 
-## Usage (alpha.1)
+### `autopilot hook`
 
-CLI surface is limited to `preflight` in alpha.1. `run`, `init`, `validate`, `codex-pr-review`, `bugbot` land in alpha.4.
+Manages a `pre-push` git hook that runs snapshot regression tests before every push.
 
 ```bash
-npx autopilot          # runs preflight
+npx autopilot hook install          # write .git/hooks/pre-push
+npx autopilot hook install --force  # overwrite existing
+npx autopilot hook uninstall        # remove
+npx autopilot hook status           # show installed hook content
 ```
 
-## Preset quick-start
+Works in git worktrees (handles `.git` as a file pointer).
+
+### `autopilot autoregress`
+
+Impact-aware snapshot regression testing. Only fires tests whose source modules (or one-hop importers) were touched by the current branch.
 
 ```bash
-cp presets/nextjs-supabase/autopilot.config.yaml .
-# Edit adapters / protectedPaths / testCommand as needed
-npx tsx src/cli/preflight.ts
+npx autopilot autoregress run              # impact-selected snapshots (default)
+npx autopilot autoregress run --all        # all snapshots
+npx autopilot autoregress diff             # show JSON diffs vs baselines
+npx autopilot autoregress update           # overwrite baselines with current output
+npx autopilot autoregress generate         # LLM-generate snapshot tests for changed files
+npx autopilot autoregress generate --files src/foo.ts,src/bar.ts
 ```
 
-## Roadmap
+Requires `OPENAI_API_KEY` for `generate` mode.
+
+### `autopilot init`
+
+Scaffolds `autopilot.config.yaml` from a preset.
+
+```bash
+npx autopilot init
+```
+
+Available presets: `nextjs-supabase`, `t3`, `python-fastapi`, `rails-postgres`, `go`.
+
+### `autopilot preflight`
+
+Checks prerequisites (Node version, `gh` CLI auth, `OPENAI_API_KEY`).
+
+## GitHub Actions
+
+Add to your workflow:
+
+```yaml
+- uses: axledbetter/claude-autopilot@v1
+  with:
+    openai-api-key: ${{ secrets.OPENAI_API_KEY }}
+```
+
+Runs the pipeline, uploads SARIF to GitHub Code Scanning, and annotates the PR diff inline.
+
+## SARIF Output
+
+```bash
+npx autopilot run --format sarif --output autopilot.sarif
+```
+
+Compatible with `github/codeql-action/upload-sarif@v3`.
+
+## Config (`autopilot.config.yaml`)
+
+```yaml
+preset: nextjs-supabase          # inherit a base config
+reviewEngine:
+  adapter: codex
+  options:
+    model: gpt-5.3-codex
+testCommand: npm test
+protect:
+  - src/core/**
+  - data/deltas/**
+```
+
+## Snapshot Regression Testing
+
+After each feature lands, generate behavioral baselines:
+
+```bash
+npx autopilot autoregress generate
+```
+
+Future PRs automatically fail if covered behavior diverges. The impact selector uses `git merge-base` diff + one-hop import graph expansion so only relevant snapshots run — keeping CI token-efficient.
+
+High-impact paths (`src/core/pipeline/**`, `src/adapters/**`, `src/core/findings/**`, `src/core/config/**`) always trigger a full run.
+
+## Architecture
+
+Four pluggable adapter points:
+
+| Point | Built-in | Purpose |
+|---|---|---|
+| `review-engine` | `codex` | LLM code review |
+| `vcs-host` | `github` | PR comments + SARIF upload |
+| `migration-runner` | `supabase` | DB migration execution |
+| `review-bot-parser` | `cursor` | Parse review bot comments |
+
+## Requirements
 
-- **alpha.2:** chunking, cost, cache, remaining adapters, 5 presets, 20 scenario tests
-- **alpha.3:** idempotency wiring, concurrency, adapter trust, 60 conformance + 13 safety tests
-- **alpha.4:** full CLI (init, install-github-action, run --resume, etc.) + programmatic API
-- **beta → 1.0.0:** dogfood + npm publish
+- Node ≥ 22
+- `OPENAI_API_KEY` (optional — review engine and `autoregress generate` only)
+- `gh` CLI authenticated (optional — PR creation / vcs-host adapter)
 
 ## License
 
-MIT.
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.8",
   "type": "module",
   "description": "Claude Code automation pipeline: spec → plan → implement → validate → PR",
   "keywords": ["claude", "autopilot", "ai", "pipeline", "code-review", "cli"],

package/src/cli/autoregress-bridge.ts

@@ -0,0 +1,30 @@
+// src/cli/autoregress-bridge.ts
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.resolve(__dirname, '../../scripts/autoregress.ts');
+
+const VALID_MODES = ['run', 'update', 'generate', 'diff'];
+
+export function buildAutoregressArgs(args: string[]): string[] {
+  const mode = args[0] && VALID_MODES.includes(args[0]) ? args[0] : 'run';
+  const rest = args[0] && VALID_MODES.includes(args[0]) ? args.slice(1) : args;
+  return [mode, ...rest];
+}
+
+export function runAutoregress(args: string[]): number {
+  const resolvedArgs = buildAutoregressArgs(args);
+  const result = spawnSync(
+    process.execPath,
+    ['--import', 'tsx', SCRIPT, ...resolvedArgs],
+    { stdio: 'inherit', cwd: process.cwd() },
+  );
+  if (result.error) {
+    console.error(`[autoregress] failed to launch: ${result.error.message}`);
+    console.error(`  script: ${SCRIPT}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}

package/src/cli/index.ts

@@ -16,7 +16,7 @@ import { runWatch } from './watch.ts';
 
 const args = process.argv.slice(2);
 
-const SUBCOMMANDS = ['init', 'run', 'preflight', 'help', '--help', '-h'] as const;
+const SUBCOMMANDS = ['init', 'run', 'watch', 'hook', 'autoregress', 'preflight', 'help', '--help', '-h'] as const;
 const VALUE_FLAGS = ['base', 'config', 'files', 'format', 'output', 'debounce'];
 
 // Detect first non-flag arg as subcommand, default to 'run'
@@ -47,6 +47,7 @@ Commands:
   watch        Watch for file changes and re-run pipeline on each save
   init         Scaffold autopilot.config.yaml from a preset
   preflight    Check prerequisites
+  autoregress  Run snapshot regression tests (run|diff|update|generate)
 
 Options (run):
   --base <ref>         Git base ref for diff (default: HEAD~1)
@@ -59,6 +60,12 @@ Options (run):
 Options (watch):
   --config <path>      Path to config file (default: ./autopilot.config.yaml)
   --debounce <ms>      Debounce delay in ms (default: 300)
+
+Options (autoregress):
+  --all                    Run/diff all snapshots
+  --since <ref>            Git ref for changed-files detection
+  --snapshot <slug>        Target a single snapshot
+  --files <a,b,c>          Explicit file list for generate (skips git detection)
 `);
 }
 
@@ -127,6 +134,13 @@ switch (subcommand) {
     break;
   }
 
+  case 'autoregress': {
+    const { runAutoregress } = await import('./autoregress-bridge.ts');
+    const code = runAutoregress(args.slice(1));
+    process.exit(code);
+    break;
+  }
+
   default:
     console.error(`\x1b[31m[autopilot] Unknown subcommand: "${subcommand}"\x1b[0m`);
     printUsage();