@delegance/claude-autopilot 2.4.0 → 5.0.0-alpha.1

package/src/cli/scan.ts

@@ -0,0 +1,233 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { loadConfig } from '../core/config/loader.ts';
+import { loadAdapter } from '../adapters/loader.ts';
+import type { ReviewEngine } from '../adapters/review-engine/types.ts';
+import { runReviewPhase } from '../core/pipeline/review-phase.ts';
+import { detectStack } from '../core/detect/stack.ts';
+import { loadIgnoreRules, parseConfigIgnore, applyIgnoreRules } from '../core/ignore/index.ts';
+import { saveCachedFindings } from '../core/persist/findings-cache.ts';
+import type { GuardrailConfig } from '../core/config/types.ts';
+import { detectLLMKey, LLM_KEY_HINTS } from '../core/detect/llm-key.ts';
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', cyan: '\x1b[36m',
+};
+const fmt = (c: keyof typeof C, t: string) => `${C[c]}${t}${C.reset}`;
+
+const IGNORED_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'coverage',
+  '.guardrail-cache', '.autopilot', '__pycache__', '.venv', 'vendor',
+]);
+
+const CODE_EXTS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.go', '.rb', '.rs', '.java', '.kt', '.swift',
+  '.c', '.cpp', '.h', '.cs', '.php',
+  '.sql', '.sh', '.bash', '.yaml', '.yml', '.json', '.toml',
+]);
+
+function collectFiles(target: string, cwd: string): string[] {
+  const abs = path.isAbsolute(target) ? target : path.resolve(cwd, target);
+  if (!fs.existsSync(abs)) return [];
+
+  const stat = fs.statSync(abs);
+  if (stat.isFile()) return [abs];
+
+  const results: string[] = [];
+  function walk(dir: string) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && CODE_EXTS.has(path.extname(entry.name))) {
+        results.push(full);
+      }
+    }
+  }
+  walk(abs);
+  return results;
+}
+
+function collectAllFiles(cwd: string): string[] {
+  return collectFiles(cwd, cwd);
+}
+
+export interface ScanCommandOptions {
+  cwd?: string;
+  configPath?: string;
+  targets?: string[];   // explicit paths/dirs to scan
+  all?: boolean;        // scan entire codebase
+  ask?: string;         // targeted question to inject into review prompt
+  focus?: 'security' | 'logic' | 'performance' | 'brand' | 'all';
+  dryRun?: boolean;
+}
+
+export async function runScan(options: ScanCommandOptions = {}): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
+
+  let config: GuardrailConfig = { configVersion: 1 };
+  if (fs.existsSync(configPath)) {
+    const loaded = await loadConfig(configPath);
+    if (loaded) config = loaded;
+  }
+
+  // Collect files
+  let files: string[];
+  if (options.all) {
+    files = collectAllFiles(cwd);
+  } else if (options.targets && options.targets.length > 0) {
+    files = options.targets.flatMap(t => collectFiles(t, cwd));
+  } else {
+    console.error(fmt('red', '[scan] Specify a path, --all, or use `guardrail run` for git-changed files'));
+    console.error(fmt('dim', '  Examples:'));
+    console.error(fmt('dim', '    guardrail scan src/auth/'));
+    console.error(fmt('dim', '    guardrail scan --all'));
+    console.error(fmt('dim', '    guardrail scan --ask "is there SQL injection?" src/db/'));
+    return 1;
+  }
+
+  // Deduplicate
+  files = [...new Set(files)];
+
+  if (files.length === 0) {
+    console.log(fmt('yellow', '[scan] No code files found at the specified path(s)'));
+    return 0;
+  }
+
+  if (options.dryRun) {
+    console.log(fmt('bold', `[scan] Would scan ${files.length} file(s):`));
+    for (const f of files) console.log(fmt('dim', `  ${path.relative(cwd, f)}`));
+    return 0;
+  }
+
+  // Auto-detect stack if not in config
+  if (!config.stack) {
+    config = { ...config, stack: detectStack(cwd) ?? undefined };
+  }
+
+  // Build review engine
+  if (!detectLLMKey().hasKey) {
+    console.error(fmt('red', '[scan] No LLM API key — set one of:'));
+    for (const { name, url, note } of LLM_KEY_HINTS) {
+      const suffix = note ? `  (${note})` : '';
+      console.error(fmt('dim', `         ${name.padEnd(18)} ${url}${suffix}`));
+    }
+    return 1;
+  }
+  const engineRef = typeof config.reviewEngine === 'string' ? config.reviewEngine
+    : (config.reviewEngine?.adapter ?? 'auto');
+  let engine: ReviewEngine;
+  try {
+    engine = await loadAdapter<ReviewEngine>({
+      point: 'review-engine',
+      ref: engineRef,
+      options: typeof config.reviewEngine === 'object' ? config.reviewEngine.options as Record<string, unknown> : undefined,
+    });
+  } catch (err) {
+    console.error(fmt('red', `[scan] Could not load review engine: ${err instanceof Error ? err.message : String(err)}`));
+    return 1;
+  }
+
+  const focusLabel = options.focus && options.focus !== 'all' ? options.focus : null;
+  const relFiles = files.map(f => path.relative(cwd, f));
+
+  console.log('');
+  const scopeDesc = options.all ? 'entire codebase' : relFiles.slice(0, 3).join(', ') + (relFiles.length > 3 ? ` +${relFiles.length - 3} more` : '');
+  console.log(fmt('bold', `[guardrail scan]`) + fmt('dim', ` ${files.length} file(s) — ${scopeDesc}`));
+  if (options.ask) console.log(fmt('dim', `  question: ${options.ask}`));
+  if (focusLabel) console.log(fmt('dim', `  focus: ${focusLabel}`));
+  console.log('');
+
+  // Build a focused git summary / prompt context
+  const focusHint = buildFocusHint(options.ask, focusLabel);
+
+  const result = await runReviewPhase({
+    touchedFiles: relFiles,
+    engine,
+    config,
+    cwd,
+    gitSummary: focusHint,
+  });
+
+  // Apply ignore rules
+  const ignoreRules = [...loadIgnoreRules(cwd), ...parseConfigIgnore(config.ignore)];
+  const findings = applyIgnoreRules(result.findings, ignoreRules);
+
+  // Print results
+  if (findings.length === 0 && options.ask && result.rawOutputs && result.rawOutputs.length > 0) {
+    // --ask returned prose rather than structured findings — surface raw response
+    console.log(fmt('cyan', `Answer:`));
+    for (const raw of result.rawOutputs) {
+      // Strip markdown fences and the ## Findings / ## Review Summary headers if present
+      const cleaned = raw.replace(/^##\s+Review Summary\s*\n/gm, '').replace(/^##\s+Findings\s*\n/gm, '').trim();
+      console.log(cleaned);
+    }
+    console.log('');
+  } else if (findings.length === 0) {
+    console.log(fmt('green', '✓ No findings'));
+  } else {
+    const critical = findings.filter(f => f.severity === 'critical');
+    const warnings = findings.filter(f => f.severity === 'warning');
+    const notes    = findings.filter(f => f.severity === 'note');
+
+    if (critical.length > 0) {
+      console.log(fmt('red', `🚨 ${critical.length} critical`));
+      for (const f of critical) {
+        const loc = f.file && f.file !== '<unspecified>' ? fmt('dim', `${f.file}${f.line ? `:${f.line}` : ''}`) + ' ' : '';
+        console.log(`  ${loc}${f.message}`);
+        if (f.suggestion) console.log(fmt('dim', `    → ${f.suggestion}`));
+      }
+      console.log('');
+    }
+    if (warnings.length > 0) {
+      console.log(fmt('yellow', `⚠  ${warnings.length} warning${warnings.length !== 1 ? 's' : ''}`));
+      for (const f of warnings) {
+        const loc = f.file && f.file !== '<unspecified>' ? fmt('dim', `${f.file}${f.line ? `:${f.line}` : ''}`) + ' ' : '';
+        console.log(`  ${loc}${f.message}`);
+        if (f.suggestion) console.log(fmt('dim', `    → ${f.suggestion}`));
+      }
+      console.log('');
+    }
+    if (notes.length > 0) {
+      console.log(fmt('dim', `ℹ  ${notes.length} note${notes.length !== 1 ? 's' : ''}`));
+      for (const f of notes) {
+        const loc = f.file && f.file !== '<unspecified>' ? `${f.file}${f.line ? `:${f.line}` : ''} ` : '';
+        console.log(fmt('dim', `  ${loc}${f.message}`));
+      }
+      console.log('');
+    }
+  }
+
+  // Persist findings so `guardrail fix` can read them
+  saveCachedFindings(cwd, findings);
+
+  if (result.costUSD !== undefined) {
+    console.log(fmt('dim', `  $${result.costUSD.toFixed(4)} · ${result.durationMs}ms`));
+  }
+
+  const fixable = findings.filter(f => f.severity === 'critical' || f.severity === 'warning');
+  if (fixable.length > 0) {
+    console.log(fmt('dim', `  → run \`guardrail fix\` to auto-fix ${fixable.length} finding${fixable.length !== 1 ? 's' : ''}`));
+  }
+
+  return findings.some(f => f.severity === 'critical') ? 1 : 0;
+}
+
+function buildFocusHint(ask: string | undefined, focus: string | null): string {
+  const parts: string[] = [];
+  if (ask) {
+    parts.push(
+      `TARGETED QUESTION (required): The reviewer specifically wants to know: "${ask}". ` +
+      `You MUST answer this question using the structured findings format. ` +
+      `Even if no issues are found, output at least one ### [NOTE] finding that directly answers the question.`,
+    );
+  }
+  if (focus === 'security') parts.push('Focus: security vulnerabilities, auth issues, injection risks, data exposure');
+  if (focus === 'logic') parts.push('Focus: logic bugs, incorrect behavior, edge cases, null handling, async errors');
+  if (focus === 'performance') parts.push('Focus: performance issues, N+1 queries, blocking I/O, memory leaks');
+  return parts.join(' | ');
+}

package/src/cli/setup.ts

@@ -5,9 +5,13 @@ import { fileURLToPath } from 'node:url';
 import { detectProject } from './detector.ts';
 import { runHook } from './hook.ts';
 import { runDoctor } from './preflight.ts';
+import { detectLLMKey, LLM_KEY_NAMES } from '../core/detect/llm-key.ts';
 
 const PASS = '\x1b[32m✓\x1b[0m';
 const WARN = '\x1b[33m!\x1b[0m';
+const DIM  = (t: string) => `\x1b[2m${t}\x1b[0m`;
+const BOLD = (t: string) => `\x1b[1m${t}\x1b[0m`;
+const CYAN = (t: string) => `\x1b[36m${t}\x1b[0m`;
 
 const PRESET_LABELS: Record<string, string> = {
   'nextjs-supabase': 'Next.js + Supabase',
@@ -15,19 +19,69 @@ const PRESET_LABELS: Record<string, string> = {
   'rails-postgres': 'Ruby on Rails + PostgreSQL',
   'python-fastapi': 'Python FastAPI',
   'go': 'Go + PostgreSQL',
+  'generic': 'Generic (no stack-specific assumptions)',
+};
+
+export type ProfileName = 'security-strict' | 'team' | 'solo';
+
+const PROFILES: Record<ProfileName, { label: string; overlay: string }> = {
+  'security-strict': {
+    label: 'Security Strict',
+    overlay: [
+      'staticRules:',
+      '  - hardcoded-secrets',
+      '  - npm-audit',
+      '  - package-lock-sync',
+      '  - sql-injection',
+      '  - missing-auth',
+      '  - ssrf',
+      '  - insecure-redirect',
+      'policy:',
+      '  failOn: warning',
+      '  newOnly: false',
+    ].join('\n'),
+  },
+  'team': {
+    label: 'Team',
+    overlay: [
+      'staticRules:',
+      '  - hardcoded-secrets',
+      '  - npm-audit',
+      '  - package-lock-sync',
+      '  - sql-injection',
+      '  - missing-auth',
+      '  - ssrf',
+      '  - insecure-redirect',
+      'policy:',
+      '  failOn: critical',
+      '  newOnly: false',
+    ].join('\n'),
+  },
+  'solo': {
+    label: 'Solo Dev',
+    overlay: [
+      'staticRules:',
+      '  - hardcoded-secrets',
+      '  - npm-audit',
+      'policy:',
+      '  failOn: critical',
+      '  newOnly: false',
+    ].join('\n'),
+  },
 };
 
 export interface SetupOptions {
   cwd?: string;
   force?: boolean;
   skipHook?: boolean;
+  profile?: ProfileName;
 }
 
 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'),
+    path.join(pkgRoot, 'presets', name, 'guardrail.config.yaml'),
+    path.join(cwd, 'node_modules', '@delegance', 'claude-autopilot', 'presets', name, 'guardrail.config.yaml'),
   ];
 }
 
@@ -40,24 +94,35 @@ function findPresetConfig(name: string, cwd: string): string | null {
 
 export async function runSetup(options: SetupOptions = {}): Promise<void> {
   const cwd = options.cwd ?? process.cwd();
-  const dest = path.join(cwd, 'autopilot.config.yaml');
+  const dest = path.join(cwd, 'guardrail.config.yaml');
 
   if (fs.existsSync(dest) && !options.force) {
-    throw new Error('autopilot.config.yaml already exists — use --force to overwrite');
+    throw new Error('guardrail.config.yaml already exists — use --force to overwrite');
   }
 
-  console.log('\n[setup] Detecting project type...');
+  console.log(`\n${BOLD('[guardrail setup]')} ${DIM(cwd)}\n`);
+  console.log(`${BOLD('Detecting project…')}\n`);
 
   const detection = detectProject(cwd);
   const label = PRESET_LABELS[detection.preset] ?? detection.preset;
 
   if (detection.confidence === 'high') {
-    console.log(`  ${PASS}  ${label} (${detection.evidence})`);
+    console.log(`  ${PASS}  Stack:        ${label}`);
+    console.log(`  ${PASS}  Evidence:     ${DIM(detection.evidence)}`);
+  } else {
+    console.log(`  ${WARN}  Stack:        ${label} ${DIM('(low confidence — fallback preset)')}`);
+    console.log(`       ${DIM(detection.evidence)}`);
+    console.log(`       ${DIM('Edit guardrail.config.yaml to switch presets if needed')}`);
+  }
+  console.log(`  ${PASS}  Test command: ${DIM(detection.testCommand)}`);
+
+  const { hasKey, preferred } = detectLLMKey();
+  if (hasKey) {
+    console.log(`  ${PASS}  LLM API key:  detected (${preferred})`);
   } 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(`  ${WARN}  LLM API key:  not found`);
+    console.log(`       ${DIM(`Set one of: ${LLM_KEY_NAMES.join(', ')}`)}`);
   }
-  console.log(`  ${PASS}  Test command: ${detection.testCommand}`);
 
   const presetConfigPath = findPresetConfig(detection.preset, cwd);
   if (!presetConfigPath) {
@@ -66,20 +131,61 @@ export async function runSetup(options: SetupOptions = {}): Promise<void> {
 
   let presetContent = await fsAsync.readFile(presetConfigPath, 'utf8');
   presetContent = presetContent.trimEnd() + `\ntestCommand: "${detection.testCommand}"\n`;
+
+  // Apply profile overlay if specified
+  if (options.profile) {
+    const profile = PROFILES[options.profile];
+    if (profile) {
+      console.log(`  ${PASS}  Profile:      ${profile.label}`);
+      // Profile overlay replaces staticRules + policy sections from preset
+      presetContent = presetContent
+        .replace(/^staticRules:.*?(?=^\w|\z)/ms, '')
+        .replace(/^policy:.*?(?=^\w|\z)/ms, '');
+      presetContent = presetContent.trimEnd() + `\n${profile.overlay}\n`;
+    }
+  }
+
   await fsAsync.writeFile(dest, presetContent, 'utf8');
-  console.log(`  ${PASS}  Created autopilot.config.yaml`);
 
+  console.log(`\n${BOLD('Config written to guardrail.config.yaml:')}\n`);
+  for (const line of presetContent.trimEnd().split('\n')) {
+    console.log(`  ${DIM(line)}`);
+  }
+
+  let hookInstalled = false;
   if (!options.skipHook) {
     const hookCode = await runHook('install', { cwd, silent: true });
-    if (hookCode === 0) {
-      console.log(`  ${PASS}  Installed pre-push git hook`);
+    hookInstalled = hookCode === 0;
+    if (hookInstalled) {
+      console.log(`\n  ${PASS}  Pre-push git hook installed`);
     } else {
-      console.log(`  ${WARN}  Hook install failed (not fatal — run: npx autopilot hook install)`);
+      console.log(`\n  ${WARN}  Hook install failed (run: npx guardrail hook install)`);
     }
   }
 
-  console.log('\n[setup] Checking prerequisites...');
+  console.log('\nChecking prerequisites…');
   await runDoctor();
 
-  console.log('\n[setup] Done. Run: npx autopilot run\n');
+  console.log(`\n${BOLD('Next steps:')}\n`);
+  if (!hasKey) {
+    console.log(`  1. ${CYAN('Set an LLM API key')} — guardrail needs one to review code:`);
+    console.log(`       export ANTHROPIC_API_KEY=sk-ant-...     # https://console.anthropic.com/`);
+    console.log(`       export OPENAI_API_KEY=sk-...            # https://platform.openai.com/api-keys`);
+    console.log(`       export GROQ_API_KEY=gsk_...             # https://console.groq.com/keys (free)\n`);
+    console.log(`  2. ${CYAN('Review your changes:')}`);
+    console.log(`       npx guardrail run --base main\n`);
+    console.log(`  3. ${CYAN('Scan any path directly:')}`);
+    console.log(`       npx guardrail scan src/auth/\n`);
+  } else {
+    console.log(`  ${CYAN('Review git-changed files:')}`);
+    console.log(`    npx guardrail run --base main\n`);
+    console.log(`  ${CYAN('Scan any path (no git needed):')}`);
+    console.log(`    npx guardrail scan src/auth/\n`);
+    console.log(`  ${CYAN('Ask a targeted question:')}`);
+    console.log(`    npx guardrail scan --ask "is there SQL injection here?" src/db/\n`);
+    if (!hookInstalled && !options.skipHook) {
+      console.log(`  ${CYAN('Install pre-push hook (auto-runs before git push):')}`);
+      console.log(`    npx guardrail hook install\n`);
+    }
+  }
 }

package/src/cli/test-gen.ts

@@ -0,0 +1,125 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { loadConfig } from '../core/config/loader.ts';
+import { loadAdapter } from '../adapters/loader.ts';
+import type { ReviewEngine } from '../adapters/review-engine/types.ts';
+import { findCoverageGaps } from '../core/test-gen/coverage-analyzer.ts';
+import { detectTestFramework } from '../core/test-gen/framework-detector.ts';
+import { writeGeneratedTest, buildGenerationPrompt } from '../core/test-gen/test-writer.ts';
+
+const C = { reset: '\x1b[0m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', dim: '\x1b[2m', bold: '\x1b[1m', cyan: '\x1b[36m' };
+
+export interface TestGenOptions {
+  cwd?: string;
+  configPath?: string;
+  targets?: string[];
+  base?: string;
+  dryRun?: boolean;
+  verify?: boolean;
+}
+
+export async function runTestGen(options: TestGenOptions = {}): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
+
+  let config = { configVersion: 1 as const, testCommand: null as string | null };
+  if (fs.existsSync(configPath)) {
+    try {
+      const loaded = await loadConfig(configPath);
+      if (loaded) config = loaded as typeof config;
+    } catch {
+      // proceed with defaults if config fails to load
+    }
+  }
+
+  // Collect files to analyze
+  let files: string[];
+  if (options.targets && options.targets.length > 0) {
+    files = options.targets.map(t => path.isAbsolute(t) ? t : path.resolve(cwd, t));
+  } else {
+    // Fall back to git-changed files
+    try {
+      const base = options.base ?? 'HEAD~1';
+      const out = execFileSync('git', ['diff', '--name-only', base, 'HEAD'], { cwd, encoding: 'utf8' });
+      files = out.trim().split('\n').filter(Boolean).map(f => path.resolve(cwd, f));
+    } catch {
+      console.error(`${C.red}[test-gen] No targets specified and git diff failed. Pass a path: guardrail test-gen src/${C.reset}`);
+      return 1;
+    }
+  }
+
+  console.log(`${C.bold}[test-gen]${C.reset} Analyzing ${files.length} file(s)...`);
+  const gaps = findCoverageGaps(files);
+
+  if (gaps.length === 0) {
+    console.log(`${C.green}[test-gen] No coverage gaps found${C.reset}`);
+    return 0;
+  }
+
+  for (const gap of gaps) {
+    const rel = path.relative(cwd, gap.file);
+    const covered = gap.exports.length;
+    console.log(`  ${C.cyan}${rel}${C.reset}  ${covered} uncovered export(s): ${gap.exports.join(', ')}`);
+  }
+
+  if (options.dryRun) {
+    console.log(`\n${C.yellow}[test-gen] Dry run — not generating tests${C.reset}`);
+    return 0;
+  }
+
+  // Load review engine for generation
+  const engineRef = (config as { reviewEngine?: unknown }).reviewEngine ?? 'auto';
+  let engine: Awaited<ReturnType<typeof loadAdapter>>;
+  try {
+    engine = await loadAdapter({ point: 'review-engine', ref: engineRef as string });
+  } catch (err) {
+    console.error(`${C.red}[test-gen] Could not load review engine: ${err}${C.reset}`);
+    return 1;
+  }
+
+  const framework = detectTestFramework(cwd);
+  const written: string[] = [];
+
+  for (const gap of gaps) {
+    let sourceContent: string;
+    try { sourceContent = fs.readFileSync(gap.file, 'utf8'); } catch { continue; }
+
+    const prompt = buildGenerationPrompt(gap, sourceContent, framework);
+
+    process.stdout.write(`  Generating ${path.relative(cwd, gap.testFile)}... `);
+    try {
+      const result = await (engine as unknown as ReviewEngine).review({ content: prompt, kind: 'spec', context: { cwd } });
+
+      // Extract code block if wrapped in markdown
+      let code = result.rawOutput.trim();
+      const fenceMatch = code.match(/```(?:typescript|ts|javascript|js)?\n([\s\S]*?)```/);
+      if (fenceMatch) code = fenceMatch[1]!.trim();
+
+      const testPath = writeGeneratedTest(gap, code);
+      written.push(testPath);
+      console.log(`${C.green}done${C.reset}`);
+
+      // Verify mode
+      if (options.verify && config.testCommand) {
+        try {
+          const [cmd, ...cmdArgs] = config.testCommand.split(/\s+/);
+          execFileSync(cmd!, cmdArgs, { cwd, stdio: 'ignore', timeout: 60_000 });
+        } catch {
+          fs.unlinkSync(testPath);
+          written.pop();
+          console.log(`  ${C.yellow}  ↳ tests failed — reverted${C.reset}`);
+        }
+      }
+    } catch (err) {
+      console.log(`${C.red}failed: ${err}${C.reset}`);
+    }
+  }
+
+  if (written.length > 0) {
+    console.log(`\n${C.green}[test-gen] Generated ${written.length} test file(s):${C.reset}`);
+    for (const f of written) console.log(`  ${path.relative(cwd, f)}`);
+  }
+
+  return 0;
+}