@delegance/claude-autopilot 5.0.1 → 5.0.2

package/src/cli/fix.ts

@@ -1,249 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as readline from 'node:readline';
-import { execSync } from 'node:child_process';
-import { loadCachedFindings } from '../core/persist/findings-cache.ts';
-import { loadConfig } from '../core/config/loader.ts';
-import { loadAdapter } from '../adapters/loader.ts';
-import type { ReviewEngine } from '../adapters/review-engine/types.ts';
-import type { Finding } from '../core/findings/types.ts';
-import type { GuardrailConfig } from '../core/config/types.ts';
-import { generateFix, buildUnifiedDiff, type GenerateResult } from '../core/fix/generator.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}`;
-
-export interface FixCommandOptions {
-  cwd?: string;
-  configPath?: string;
-  severity?: 'critical' | 'warning' | 'all';
-  dryRun?: boolean;
-  yes?: boolean;      // skip per-fix confirmation prompts
-  noVerify?: boolean; // skip test verification after applying fix
-}
-
-interface FixResult {
-  file: string;
-  line: number;
-  findingMessage: string;
-  status: 'fixed' | 'skipped' | 'rejected' | 'failed';
-  reason?: string;
-}
-
-async function confirmFix(diff: string, finding: Finding): Promise<'yes' | 'no' | 'quit'> {
-  console.log('');
-  console.log(diff);
-  console.log('');
-
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise(resolve => {
-    rl.question(fmt('bold', '  Apply this fix? [y]es / [n]o / [q]uit  '), answer => {
-      rl.close();
-      const a = answer.trim().toLowerCase();
-      if (a === 'q') resolve('quit');
-      else if (a === 'y' || a === '') resolve('yes');
-      else resolve('no');
-    });
-  });
-}
-
-export async function runFix(options: FixCommandOptions = {}): Promise<number> {
-  const cwd = options.cwd ?? process.cwd();
-  const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
-  const severityFilter = options.severity ?? 'critical';
-
-  const findings = loadCachedFindings(cwd);
-  if (findings.length === 0) {
-    console.log(fmt('yellow', '[fix] No cached findings — run `guardrail scan <path>` or `guardrail run` first.'));
-    return 0;
-  }
-
-  const fixable = findings.filter(f => {
-    if (!f.line || !f.file || f.file === '<unspecified>' || f.file === '<pipeline>') return false;
-    if (severityFilter === 'all') return true;
-    if (severityFilter === 'critical') return f.severity === 'critical';
-    return f.severity === 'critical' || f.severity === 'warning';
-  });
-
-  if (fixable.length === 0) {
-    console.log(fmt('yellow', `[fix] No fixable findings (severity=${severityFilter}, need file+line).`));
-    return 0;
-  }
-
-  const modeNote = options.dryRun ? ' (dry run)' : options.yes ? '' : ' (interactive — use --yes to skip prompts)';
-  console.log(`\n${fmt('bold', '[fix]')} ${fixable.length} finding${fixable.length !== 1 ? 's' : ''} to attempt${modeNote}\n`);
-
-  // Print upfront summary of all fixable findings before prompting
-  for (const f of fixable) {
-    const sev = f.severity === 'critical' ? fmt('red', 'CRITICAL') : fmt('yellow', 'WARNING ');
-    const loc = fmt('dim', `${f.file}:${f.line}`);
-    console.log(`  [${sev}] ${loc} ${f.message}`);
-    if (f.suggestion) console.log(fmt('dim', `           → ${f.suggestion}`));
-  }
-  console.log('');
-
-  // Dry-run: listing the findings is sufficient — no LLM needed
-  if (options.dryRun) {
-    console.log(fmt('yellow', `[fix] Dry run — ${fixable.length} finding${fixable.length !== 1 ? 's' : ''} listed above, no files modified.\n`));
-    return 0;
-  }
-
-  // Load config + review engine (config optional — defaults to auto adapter)
-  let engine: ReviewEngine;
-  let loadedConfig: GuardrailConfig | null = null;
-  try {
-    loadedConfig = fs.existsSync(configPath) ? await loadConfig(configPath) : null;
-    const ref = loadedConfig
-      ? (typeof loadedConfig.reviewEngine === 'string' ? loadedConfig.reviewEngine : (loadedConfig.reviewEngine?.adapter ?? 'auto'))
-      : 'auto';
-    engine = await loadAdapter<ReviewEngine>({
-      point: 'review-engine',
-      ref,
-      options: loadedConfig && typeof loadedConfig.reviewEngine === 'object' ? loadedConfig.reviewEngine.options : undefined,
-    });
-  } catch (err) {
-    console.error(fmt('red', `[fix] Could not load review engine: ${err instanceof Error ? err.message : String(err)}`));
-    return 1;
-  }
-
-  const testCommand = loadedConfig?.testCommand ?? null;
-  const shouldVerify = !options.noVerify && !!testCommand;
-  if (shouldVerify) {
-    console.log(fmt('dim', `[fix] Verified mode — running "${testCommand}" after each fix\n`));
-  }
-
-  const results: FixResult[] = [];
-  let quit = false;
-
-  for (const finding of fixable) {
-    if (quit) {
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'skipped', reason: 'user quit' });
-      continue;
-    }
-
-    const sev = finding.severity === 'critical' ? fmt('red', 'CRITICAL') : fmt('yellow', 'WARNING');
-    console.log(`\n  [${sev}] ${fmt('dim', `${finding.file}:${finding.line}`)} ${finding.message}`);
-
-    const result = await generateFix(finding, engine, cwd);
-
-    if (result.status === 'cannot_fix') {
-      console.log(fmt('dim', `    → skipped: ${result.reason}`));
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'skipped', reason: result.reason });
-      continue;
-    }
-
-    if (result.status === 'rejected') {
-      console.log(fmt('yellow', `    → rejected: ${result.reason}`));
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'rejected', reason: result.reason });
-      continue;
-    }
-
-    if (result.status === 'error') {
-      console.log(fmt('red', `    → error: ${result.reason}`));
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'failed', reason: result.reason });
-      continue;
-    }
-
-    // Show diff
-    const diff = buildUnifiedDiff(result.originalLines!, result.replacementLines!, finding.file, result.startLine!);
-
-    if (options.dryRun) {
-      console.log('');
-      console.log(diff);
-      console.log(fmt('dim', '    (dry run — not applied)'));
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'skipped', reason: 'dry run' });
-      continue;
-    }
-
-    // Interactive confirmation (unless --yes)
-    if (!options.yes) {
-      const answer = await confirmFix(diff, finding);
-      if (answer === 'quit') {
-        quit = true;
-        results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'skipped', reason: 'user quit' });
-        continue;
-      }
-      if (answer === 'no') {
-        results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'skipped', reason: 'user declined' });
-        continue;
-      }
-    } else {
-      // --yes mode: still print the diff so there's a record
-      console.log('');
-      console.log(diff);
-    }
-
-    // Apply fix atomically
-    try {
-      const absPath = path.resolve(cwd, finding.file);
-      const originalContent = fs.readFileSync(absPath, 'utf8');
-      const allLines = originalContent.split('\n');
-      const newLines = [
-        ...allLines.slice(0, result.startLine! - 1),
-        ...result.replacementLines!,
-        ...allLines.slice(result.endLine!),
-      ];
-      const tmp = absPath + '.guardrail.tmp';
-      fs.writeFileSync(tmp, newLines.join('\n'), 'utf8');
-      fs.renameSync(tmp, absPath);
-
-      if (shouldVerify) {
-        // Verified mode — same shell invocation pattern as phases/tests.ts
-        console.log(fmt('dim', `    ↻ verifying…`));
-        const passed = runTestCommand(testCommand!, cwd);
-        if (passed) {
-          console.log(fmt('green', `    ✓ applied + tests pass`));
-          results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'fixed' });
-        } else {
-          fs.writeFileSync(absPath, originalContent, 'utf8');
-          console.log(fmt('yellow', `    ⚠ reverted — tests failed after fix`));
-          results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'rejected', reason: 'tests failed after fix — reverted' });
-        }
-      } else {
-        console.log(fmt('green', `    ✓ applied`));
-        results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'fixed' });
-      }
-    } catch (err) {
-      console.log(fmt('red', `    ✗ write failed: ${err instanceof Error ? err.message : String(err)}`));
-      results.push({ file: finding.file, line: finding.line!, findingMessage: finding.message, status: 'failed', reason: String(err) });
-    }
-  }
-
-  const fixed    = results.filter(r => r.status === 'fixed').length;
-  const rejected = results.filter(r => r.status === 'rejected').length;
-  const failed   = results.filter(r => r.status === 'failed').length;
-  const skipped  = results.filter(r => r.status === 'skipped').length;
-
-  console.log('');
-  if (options.dryRun) {
-    console.log(fmt('yellow', `[fix] Dry run complete — ${fixable.length} finding${fixable.length !== 1 ? 's' : ''} previewed, no files modified.\n`));
-  } else {
-    const parts = [
-      fixed   > 0 ? fmt('green',  `${fixed} fixed`)    : null,
-      rejected > 0 ? fmt('yellow', `${rejected} rejected`) : null,
-      failed  > 0 ? fmt('red',    `${failed} failed`)   : null,
-      skipped > 0 ? fmt('dim',    `${skipped} skipped`)  : null,
-    ].filter(Boolean).join(fmt('dim', ' · '));
-    console.log(`[fix] ${parts}\n`);
-  }
-
-  return failed > 0 ? 1 : 0;
-}
-
-function runTestCommand(cmd: string, cwd: string): boolean {
-  try {
-    execSync(cmd, {
-      cwd,
-      stdio: 'ignore',
-      timeout: 120000,
-      shell: process.env.SHELL ?? '/bin/sh',
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-

package/src/cli/hook.ts

@@ -1,124 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-export const GUARDRAIL_MARKER = '# guardrail-managed';
-
-const PRE_COMMIT_TEMPLATE = `#!/bin/sh
-${GUARDRAIL_MARKER}
-# guardrail pre-commit hook — runs static rules only (<1s, no LLM)
-# --files accepts comma-separated paths; quoting prevents shell word-splitting
-STAGED=$(git diff --cached --name-only --diff-filter=ACM | tr '\\n' ',')
-STAGED=\${STAGED%,}
-if [ -z "$STAGED" ]; then exit 0; fi
-npx guardrail run --static-only --files "$STAGED"
-`;
-
-const PRE_PUSH_TEMPLATE = `#!/bin/sh
-${GUARDRAIL_MARKER}
-# guardrail pre-push hook — full LLM review against upstream
-BASE=$(git rev-parse --abbrev-ref --symbolic-full-name @{u} 2>/dev/null || echo "HEAD~1")
-npx guardrail run --base "$BASE"
-`;
-
-function findGitDir(cwd: string): string | null {
-  let dir = path.resolve(cwd);
-  for (let i = 0; i < 10; i++) {
-    const candidate = path.join(dir, '.git');
-    if (fs.existsSync(candidate)) {
-      const stat = fs.statSync(candidate);
-      if (stat.isDirectory()) return candidate;
-      if (stat.isFile()) {
-        const content = fs.readFileSync(candidate, 'utf8');
-        const match = content.match(/^gitdir:\s*(.+)/m);
-        if (match) return path.resolve(dir, match[1]!.trim());
-      }
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-  return null;
-}
-
-function isGuardrailHook(hookPath: string): boolean {
-  try {
-    return fs.readFileSync(hookPath, 'utf8').includes(GUARDRAIL_MARKER);
-  } catch {
-    return false;
-  }
-}
-
-function writeHook(hookPath: string, content: string, force: boolean): boolean {
-  if (fs.existsSync(hookPath) && !force && !isGuardrailHook(hookPath)) {
-    console.error(`[hook] hook already exists at ${hookPath} (not guardrail-managed)`);
-    console.error('       Use --force to overwrite.');
-    return false;
-  }
-  fs.mkdirSync(path.dirname(hookPath), { recursive: true });
-  fs.writeFileSync(hookPath, content, 'utf8');
-  fs.chmodSync(hookPath, 0o755);
-  return true;
-}
-
-function removeHook(hookPath: string): void {
-  if (!fs.existsSync(hookPath)) return;
-  if (isGuardrailHook(hookPath)) {
-    fs.rmSync(hookPath);
-    console.log(`[hook] removed ${hookPath}`);
-  } else {
-    console.log(`[hook] skipping ${hookPath} — not guardrail-managed`);
-  }
-}
-
-export async function runHook(
-  sub: string,
-  options: { cwd?: string; force?: boolean; silent?: boolean; preCommitOnly?: boolean; prePushOnly?: boolean } = {},
-): Promise<number> {
-  const cwd = options.cwd ?? process.cwd();
-  const gitDir = findGitDir(cwd);
-
-  if (!gitDir) {
-    if (!options.silent) console.error('[hook] not inside a git repository');
-    return 1;
-  }
-
-  const hooksDir = path.join(gitDir, 'hooks');
-  const preCommitPath = path.join(hooksDir, 'pre-commit');
-  const prePushPath = path.join(hooksDir, 'pre-push');
-  const force = options.force ?? false;
-
-  switch (sub) {
-    case 'install': {
-      const installPreCommit = !options.prePushOnly;
-      const installPrePush = !options.preCommitOnly;
-      let ok = true;
-      if (installPreCommit) {
-        const written = writeHook(preCommitPath, PRE_COMMIT_TEMPLATE, force);
-        if (written) console.log(`[hook] installed pre-commit hook at ${preCommitPath}`);
-        else ok = false;
-      }
-      if (installPrePush) {
-        const written = writeHook(prePushPath, PRE_PUSH_TEMPLATE, force);
-        if (written) console.log(`[hook] installed pre-push hook at ${prePushPath}`);
-        else ok = false;
-      }
-      return ok ? 0 : 1;
-    }
-    case 'uninstall': {
-      removeHook(preCommitPath);
-      removeHook(prePushPath);
-      return 0;
-    }
-    case 'status': {
-      const pcInstalled = fs.existsSync(preCommitPath) && isGuardrailHook(preCommitPath);
-      const ppInstalled = fs.existsSync(prePushPath) && isGuardrailHook(prePushPath);
-      console.log(`[hook] pre-commit: ${pcInstalled ? 'installed (guardrail-managed)' : 'not installed'}`);
-      console.log(`[hook] pre-push:   ${ppInstalled ? 'installed (guardrail-managed)' : 'not installed'}`);
-      return 0;
-    }
-    default:
-      console.error(`[hook] unknown subcommand: ${sub}`);
-      console.error('Usage: guardrail hook <install|uninstall|status> [--force] [--pre-commit-only] [--pre-push-only]');
-      return 1;
-  }
-}

package/src/cli/ignore-helper.ts

@@ -1,116 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as readline from 'node:readline';
-import { loadCachedFindings } from '../core/persist/findings-cache.ts';
-import type { Finding } from '../core/findings/types.ts';
-
-const C = {
-  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-  green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m',
-};
-const fmt = (c: keyof typeof C, t: string) => `${C[c]}${t}${C.reset}`;
-
-const IGNORE_FILE = '.guardrail-ignore';
-
-function readIgnoreFile(cwd: string): string {
-  const p = path.join(cwd, IGNORE_FILE);
-  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
-}
-
-function appendIgnoreRule(cwd: string, rule: string): void {
-  const p = path.join(cwd, IGNORE_FILE);
-  const existing = readIgnoreFile(cwd);
-  const separator = existing && !existing.endsWith('\n') ? '\n' : '';
-  fs.appendFileSync(p, `${separator}${rule}\n`, 'utf8');
-}
-
-function isAlreadyIgnored(existing: string, rule: string): boolean {
-  return existing.split('\n').some(l => l.trim() === rule);
-}
-
-function buildRule(finding: Finding, scope: 'path' | 'rule+path' | 'rule'): string {
-  if (scope === 'path') {
-    const dir = path.dirname(finding.file);
-    return dir === '.' ? finding.file : `${dir}/**`;
-  }
-  if (scope === 'rule') return `${finding.id} **`;
-  // rule+path: most specific
-  const dir = path.dirname(finding.file);
-  const glob = dir === '.' ? finding.file : `${dir}/**`;
-  return `${finding.id} ${glob}`;
-}
-
-async function prompt(question: string): Promise<string> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise(resolve => {
-    rl.question(question, answer => { rl.close(); resolve(answer.trim()); });
-  });
-}
-
-export interface IgnoreCommandOptions {
-  cwd?: string;
-  all?: boolean;       // suppress all findings without prompting
-  dryRun?: boolean;
-}
-
-export async function runIgnore(options: IgnoreCommandOptions = {}): Promise<number> {
-  const cwd = options.cwd ?? process.cwd();
-  const findings = loadCachedFindings(cwd);
-
-  if (findings.length === 0) {
-    console.log(fmt('yellow', '[ignore] No cached findings — run `guardrail run` or `guardrail scan` first.'));
-    return 0;
-  }
-
-  const existing = readIgnoreFile(cwd);
-  let added = 0;
-
-  console.log(`\n${fmt('bold', '[ignore]')} ${findings.length} finding${findings.length !== 1 ? 's' : ''} to review\n`);
-
-  for (const [i, f] of findings.entries()) {
-    const sev = f.severity === 'critical' ? fmt('red', 'CRITICAL')
-              : f.severity === 'warning'  ? fmt('yellow', 'WARNING ')
-              : fmt('dim',   'NOTE    ');
-    const loc = f.file !== '<unspecified>' ? `${f.file}${f.line ? `:${f.line}` : ''}` : '<pipeline>';
-
-    console.log(`\n${fmt('bold', `${i + 1}/${findings.length}`)}  [${sev}] ${f.message}`);
-    console.log(fmt('dim', `     ${loc}  (rule: ${f.id})`));
-
-    let scope: string;
-    if (options.all) {
-      scope = 'r';  // rule+path
-    } else {
-      console.log(fmt('dim', '     [s] skip  [p] suppress path  [r] suppress rule+path  [R] suppress rule everywhere  [q] quit'));
-      scope = await prompt('     > ');
-    }
-
-    if (scope === 'q') break;
-    if (scope === 's' || scope === '') continue;
-
-    const ruleScope = scope === 'p' ? 'path' : scope === 'R' ? 'rule' : 'rule+path';
-    const rule = buildRule(f, ruleScope);
-
-    if (isAlreadyIgnored(existing, rule)) {
-      console.log(fmt('dim', `     (already in ${IGNORE_FILE}: ${rule})`));
-      continue;
-    }
-
-    if (options.dryRun) {
-      console.log(fmt('dim', `     (dry run) would add: ${rule}`));
-    } else {
-      appendIgnoreRule(cwd, rule);
-      console.log(fmt('green', `     + added: ${rule}`));
-    }
-    added++;
-  }
-
-  console.log('');
-  if (options.dryRun) {
-    console.log(fmt('yellow', `[ignore] Dry run — ${added} rule${added !== 1 ? 's' : ''} would be added to ${IGNORE_FILE}\n`));
-  } else if (added > 0) {
-    console.log(fmt('green', `[ignore] ${added} rule${added !== 1 ? 's' : ''} added to ${IGNORE_FILE}\n`));
-  } else {
-    console.log(fmt('dim', `[ignore] No rules added\n`));
-  }
-  return 0;
-}