@delegance/claude-autopilot 1.0.2 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [1.1.0] — 2026-04-21
+
+### Added
+- `autopilot setup` — zero-prompt setup: auto-detects project type (Go, Rails, FastAPI, T3, Next.js+Supabase), infers test command, writes config, installs git hook in one command
+- `autopilot setup --force` — overwrite existing config
+
 ## [1.0.2] — 2026-04-21
 
 ### Fixed

package/README.md

@@ -13,19 +13,15 @@ Requires Node 22+. Also requires `gh` CLI authenticated and `claude` CLI install
 ## Quick Start
 
 ```bash
-# Scaffold config
-npx autopilot init
+# One command — auto-detects project type, writes config, installs hook
+npx autopilot setup
 
-# Run on changed files
+# Then run your first pipeline
 npx autopilot run
-
-# Watch mode (re-runs on every file save)
-npx autopilot watch
-
-# Install pre-push hook
-npx autopilot hook install
 ```
 
+Requires Node 22+, `gh` CLI authenticated, `claude` CLI (Claude Code).
+
 ## Commands
 
 ### `autopilot run`
@@ -77,6 +73,17 @@ npx autopilot autoregress generate --files src/foo.ts,src/bar.ts
 
 Requires `OPENAI_API_KEY` for `generate` mode.
 
+### `autopilot setup`
+
+Zero-prompt setup: auto-detects project type, writes config, installs git hook in one command.
+
+```bash
+npx autopilot setup            # Auto-detect project, write config, install hook
+npx autopilot setup --force    # Overwrite existing autopilot.config.yaml
+```
+
+Auto-detection supports: Go, Rails, FastAPI, T3, Next.js+Supabase.
+
 ### `autopilot init`
 
 Scaffolds `autopilot.config.yaml` from a preset.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "type": "module",
   "description": "Claude Code automation pipeline: spec \u2192 plan \u2192 implement \u2192 validate \u2192 PR",
   "keywords": [

package/src/cli/detector.ts

@@ -0,0 +1,72 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export interface DetectionResult {
+  preset: string;
+  testCommand: string;
+  confidence: 'high' | 'low';
+  evidence: string;
+}
+
+function readJson(filePath: string): Record<string, unknown> | null {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function fileContains(filePath: string, needle: string): boolean {
+  try {
+    return fs.readFileSync(filePath, 'utf8').includes(needle);
+  } catch {
+    return false;
+  }
+}
+
+function nodeTestCommand(cwd: string): string {
+  const pkg = readJson(path.join(cwd, 'package.json'));
+  const scripts = pkg?.['scripts'] as Record<string, string> | undefined;
+  return scripts?.['test'] ?? 'npm test';
+}
+
+export function detectProject(cwd: string): DetectionResult {
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    return { preset: 'go', testCommand: 'go test ./...', confidence: 'high', evidence: 'found go.mod' };
+  }
+
+  const gemfile = path.join(cwd, 'Gemfile');
+  if (fs.existsSync(gemfile) && fileContains(gemfile, 'rails')) {
+    return { preset: 'rails-postgres', testCommand: 'bundle exec rails test', confidence: 'high', evidence: "found Gemfile with 'rails'" };
+  }
+
+  const reqTxt = path.join(cwd, 'requirements.txt');
+  const pyproject = path.join(cwd, 'pyproject.toml');
+  if ((fs.existsSync(reqTxt) && fileContains(reqTxt, 'fastapi')) ||
+      (fs.existsSync(pyproject) && fileContains(pyproject, 'fastapi'))) {
+    return { preset: 'python-fastapi', testCommand: 'pytest', confidence: 'high', evidence: 'found fastapi in requirements' };
+  }
+
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = readJson(pkgPath);
+    const deps = {
+      ...(pkg?.['dependencies'] as Record<string, string> ?? {}),
+      ...(pkg?.['devDependencies'] as Record<string, string> ?? {}),
+    };
+    const testCmd = nodeTestCommand(cwd);
+
+    if ('@trpc/server' in deps) {
+      return { preset: 't3', testCommand: testCmd, confidence: 'high', evidence: 'found @trpc/server in package.json' };
+    }
+    if ('next' in deps && '@supabase/supabase-js' in deps) {
+      return { preset: 'nextjs-supabase', testCommand: testCmd, confidence: 'high', evidence: 'found next + @supabase/supabase-js in package.json' };
+    }
+    if ('next' in deps) {
+      return { preset: 'nextjs-supabase', testCommand: testCmd, confidence: 'low', evidence: 'found next in package.json (no supabase detected)' };
+    }
+    return { preset: 'nextjs-supabase', testCommand: testCmd, confidence: 'low', evidence: 'found package.json (no strong framework signals)' };
+  }
+
+  return { preset: 'nextjs-supabase', testCommand: 'npm test', confidence: 'low', evidence: 'no project signals found — using default preset' };
+}

package/src/cli/index.ts

@@ -13,10 +13,11 @@
 import { runInit } from './init.ts';
 import { runCommand } from './run.ts';
 import { runWatch } from './watch.ts';
+import { runSetup } from './setup.ts';
 
 const args = process.argv.slice(2);
 
-const SUBCOMMANDS = ['init', 'run', 'watch', 'hook', 'autoregress', 'preflight', 'help', '--help', '-h'] as const;
+const SUBCOMMANDS = ['init', 'run', 'watch', 'hook', 'autoregress', 'preflight', 'setup', 'help', '--help', '-h'] as const;
 const VALUE_FLAGS = ['base', 'config', 'files', 'format', 'output', 'debounce'];
 
 // Detect first non-flag arg as subcommand, default to 'run'
@@ -141,6 +142,12 @@ switch (subcommand) {
     break;
   }
 
+  case 'setup': {
+    const force = args.includes('--force');
+    await runSetup({ force });
+    break;
+  }
+
   default:
     console.error(`\x1b[31m[autopilot] Unknown subcommand: "${subcommand}"\x1b[0m`);
     printUsage();

package/src/cli/setup.ts

@@ -0,0 +1,81 @@
+import * as fs from 'node:fs';
+import * as fsAsync from 'node:fs/promises';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { detectProject } from './detector.ts';
+import { runHook } from './hook.ts';
+
+const PASS = '\x1b[32m✓\x1b[0m';
+const WARN = '\x1b[33m!\x1b[0m';
+
+const PRESET_LABELS: Record<string, string> = {
+  'nextjs-supabase': 'Next.js + Supabase',
+  't3': 'T3 Stack (Next.js + tRPC + Prisma)',
+  'rails-postgres': 'Ruby on Rails + PostgreSQL',
+  'python-fastapi': 'Python FastAPI',
+  'go': 'Go + PostgreSQL',
+};
+
+export interface SetupOptions {
+  cwd?: string;
+  force?: boolean;
+  skipHook?: boolean;
+}
+
+function presetSearchPaths(name: string, cwd: string): string[] {
+  const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+  return [
+    path.join(pkgRoot, 'presets', name, 'autopilot.config.yaml'),
+    path.join(cwd, 'node_modules', '@delegance', 'claude-autopilot', 'presets', name, 'autopilot.config.yaml'),
+  ];
+}
+
+function findPresetConfig(name: string, cwd: string): string | null {
+  for (const p of presetSearchPaths(name, cwd)) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+export async function runSetup(options: SetupOptions = {}): Promise<void> {
+  const cwd = options.cwd ?? process.cwd();
+  const dest = path.join(cwd, 'autopilot.config.yaml');
+
+  if (fs.existsSync(dest) && !options.force) {
+    throw new Error('autopilot.config.yaml already exists — use --force to overwrite');
+  }
+
+  console.log('\n[setup] Detecting project type...');
+
+  const detection = detectProject(cwd);
+  const label = PRESET_LABELS[detection.preset] ?? detection.preset;
+
+  if (detection.confidence === 'high') {
+    console.log(`  ${PASS}  ${label} (${detection.evidence})`);
+  } else {
+    console.log(`  ${WARN}  ${label} — no strong signals found, defaulted to ${detection.preset}`);
+    console.log(`       \x1b[2mEdit autopilot.config.yaml to switch presets if needed\x1b[0m`);
+  }
+  console.log(`  ${PASS}  Test command: ${detection.testCommand}`);
+
+  const presetConfigPath = findPresetConfig(detection.preset, cwd);
+  if (!presetConfigPath) {
+    throw new Error(`Preset config not found for: ${detection.preset}. Looked in:\n  ${presetSearchPaths(detection.preset, cwd).join('\n  ')}`);
+  }
+
+  let presetContent = await fsAsync.readFile(presetConfigPath, 'utf8');
+  presetContent = presetContent.trimEnd() + `\ntestCommand: "${detection.testCommand}"\n`;
+  await fsAsync.writeFile(dest, presetContent, 'utf8');
+  console.log(`  ${PASS}  Created autopilot.config.yaml`);
+
+  if (!options.skipHook) {
+    const hookCode = await runHook('install', { cwd });
+    if (hookCode === 0) {
+      console.log(`  ${PASS}  Installed pre-push git hook`);
+    } else {
+      console.log(`  ${WARN}  Hook install failed (not fatal — run: npx autopilot hook install)`);
+    }
+  }
+
+  console.log('\n[setup] Done. Run: npx autopilot run\n');
+}