@delegance/claude-autopilot 5.0.0 → 5.0.2

package/src/core/persist/baseline.ts

@@ -1,112 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../findings/types.ts';
-
-const BASELINE_FILE = '.guardrail-baseline.json';
-
-export interface BaselineEntry {
-  id: string;
-  file: string;
-  line?: number;
-  severity: string;
-  message: string;
-  pinnedAt: string;
-  note?: string;
-}
-
-export interface Baseline {
-  version: 1;
-  createdAt: string;
-  updatedAt: string;
-  note?: string;
-  entries: BaselineEntry[];
-}
-
-/** Stable key for matching a finding against a baseline entry. */
-function baselineKey(f: { id: string; file: string; line?: number }): string {
-  return `${f.id}::${f.file}::${f.line ?? ''}`;
-}
-
-export function baselineFilePath(cwd: string, overridePath?: string): string {
-  return overridePath
-    ? path.isAbsolute(overridePath) ? overridePath : path.join(cwd, overridePath)
-    : path.join(cwd, BASELINE_FILE);
-}
-
-export function loadBaseline(cwd: string, overridePath?: string): Baseline | null {
-  const p = baselineFilePath(cwd, overridePath);
-  if (!fs.existsSync(p)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(p, 'utf8')) as Baseline;
-  } catch {
-    return null;
-  }
-}
-
-export function saveBaseline(cwd: string, findings: Finding[], options: { note?: string; overridePath?: string } = {}): Baseline {
-  const existing = loadBaseline(cwd, options.overridePath);
-  const now = new Date().toISOString();
-  const baseline: Baseline = {
-    version: 1,
-    createdAt: existing?.createdAt ?? now,
-    updatedAt: now,
-    note: options.note ?? existing?.note,
-    entries: findings.map(f => ({
-      id: f.id,
-      file: f.file,
-      line: f.line,
-      severity: f.severity,
-      message: f.message,
-      pinnedAt: now,
-    })),
-  };
-  const p = baselineFilePath(cwd, options.overridePath);
-  const tmp = p + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(baseline, null, 2), 'utf8');
-  fs.renameSync(tmp, p);
-  return baseline;
-}
-
-export function clearBaseline(cwd: string, overridePath?: string): void {
-  const p = baselineFilePath(cwd, overridePath);
-  if (fs.existsSync(p)) fs.unlinkSync(p);
-}
-
-export interface BaselineFilterResult {
-  newFindings: Finding[];
-  baselinedFindings: Finding[];
-  baselinedCount: number;
-}
-
-/** Returns findings NOT present in the baseline (new findings only). */
-export function filterBaselined(findings: Finding[], baseline: Baseline): BaselineFilterResult {
-  const pinned = new Set(baseline.entries.map(baselineKey));
-  const newFindings: Finding[] = [];
-  const baselinedFindings: Finding[] = [];
-  for (const f of findings) {
-    if (pinned.has(baselineKey(f))) {
-      baselinedFindings.push(f);
-    } else {
-      newFindings.push(f);
-    }
-  }
-  return { newFindings, baselinedFindings, baselinedCount: baselinedFindings.length };
-}
-
-export interface BaselineDiff {
-  added: Finding[];       // in current but not in baseline
-  resolved: BaselineEntry[]; // in baseline but not in current
-  unchanged: Finding[];   // in both
-}
-
-/** Diff current findings against a baseline snapshot. */
-export function diffAgainstBaseline(current: Finding[], baseline: Baseline): BaselineDiff {
-  const currentKeys = new Set(current.map(baselineKey));
-  const baselineKeys = new Set(baseline.entries.map(baselineKey));
-
-  return {
-    added:     current.filter(f => !baselineKeys.has(baselineKey(f))),
-    resolved:  baseline.entries.filter(e => !currentKeys.has(baselineKey(e))),
-    unchanged: current.filter(f => baselineKeys.has(baselineKey(f))),
-  };
-}

package/src/core/persist/cost-log.ts

@@ -1,30 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-const CACHE_DIR = '.guardrail-cache';
-const LOG_FILE = 'costs.jsonl';
-
-export interface CostLogEntry {
-  timestamp: string;
-  files: number;
-  inputTokens: number;
-  outputTokens: number;
-  costUSD: number;
-  durationMs: number;
-}
-
-export function appendCostLog(cwd: string, entry: CostLogEntry): void {
-  const dir = path.join(cwd, CACHE_DIR);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.appendFileSync(path.join(dir, LOG_FILE), JSON.stringify(entry) + '\n', 'utf8');
-}
-
-export function readCostLog(cwd: string): CostLogEntry[] {
-  const p = path.join(cwd, CACHE_DIR, LOG_FILE);
-  if (!fs.existsSync(p)) return [];
-  return fs.readFileSync(p, 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map(line => { try { return JSON.parse(line) as CostLogEntry; } catch { return null; } })
-    .filter((e): e is CostLogEntry => e !== null);
-}

package/src/core/persist/findings-cache.ts

@@ -1,43 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../findings/types.ts';
-
-const CACHE_DIR = '.guardrail-cache';
-const CACHE_FILE = 'findings.json';
-
-function cacheFilePath(cwd: string): string {
-  return path.join(cwd, CACHE_DIR, CACHE_FILE);
-}
-
-function findingKey(f: Finding): string {
-  return `${f.id}::${f.file}::${f.line ?? ''}`;
-}
-
-export function loadCachedFindings(cwd: string): Finding[] {
-  const p = cacheFilePath(cwd);
-  if (!fs.existsSync(p)) return [];
-  try {
-    return JSON.parse(fs.readFileSync(p, 'utf8')) as Finding[];
-  } catch {
-    return [];
-  }
-}
-
-export function saveCachedFindings(cwd: string, findings: Finding[]): void {
-  const dir = path.join(cwd, CACHE_DIR);
-  fs.mkdirSync(dir, { recursive: true });
-  // atomic write
-  const tmp = cacheFilePath(cwd) + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(findings, null, 2), 'utf8');
-  fs.renameSync(tmp, cacheFilePath(cwd));
-}
-
-/**
- * Returns only findings not present in the cached baseline.
- * Two findings are considered the same when id + file + line all match.
- */
-export function filterNewFindings(current: Finding[], cached: Finding[]): Finding[] {
-  if (cached.length === 0) return current;
-  const seen = new Set(cached.map(findingKey));
-  return current.filter(f => !seen.has(findingKey(f)));
-}

package/src/core/persist/triage.ts

@@ -1,112 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { Finding } from '../findings/types.ts';
-
-const TRIAGE_FILE = '.guardrail-triage.json';
-
-export type TriageState = 'accepted-risk' | 'false-positive';
-
-export interface TriageEntry {
-  id: string;
-  file: string;
-  line?: number;
-  state: TriageState;
-  reason?: string;
-  triagedAt: string;
-  expiresAt?: string;
-}
-
-export interface TriageStore {
-  version: 1;
-  entries: TriageEntry[];
-}
-
-function triageFilePath(cwd: string): string {
-  return path.join(cwd, TRIAGE_FILE);
-}
-
-function entryKey(e: { id: string; file: string; line?: number }): string {
-  return `${e.id}::${e.file}::${e.line ?? ''}`;
-}
-
-export function loadTriage(cwd: string): TriageStore {
-  const p = triageFilePath(cwd);
-  if (!fs.existsSync(p)) return { version: 1, entries: [] };
-  try {
-    return JSON.parse(fs.readFileSync(p, 'utf8')) as TriageStore;
-  } catch {
-    return { version: 1, entries: [] };
-  }
-}
-
-export function saveTriage(cwd: string, store: TriageStore): void {
-  const p = triageFilePath(cwd);
-  const tmp = p + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(store, null, 2), 'utf8');
-  fs.renameSync(tmp, p);
-}
-
-export function addTriageEntry(
-  cwd: string,
-  finding: Finding,
-  state: TriageState,
-  options: { reason?: string; expiresInDays?: number } = {},
-): void {
-  const store = loadTriage(cwd);
-  const key = entryKey(finding);
-  store.entries = store.entries.filter(e => entryKey(e) !== key);
-  const entry: TriageEntry = {
-    id: finding.id,
-    file: finding.file,
-    line: finding.line,
-    state,
-    reason: options.reason,
-    triagedAt: new Date().toISOString(),
-  };
-  if (options.expiresInDays !== undefined) {
-    const exp = new Date();
-    exp.setDate(exp.getDate() + options.expiresInDays);
-    entry.expiresAt = exp.toISOString();
-  }
-  store.entries.push(entry);
-  saveTriage(cwd, store);
-}
-
-export function removeTriageEntry(cwd: string, ids: string[]): number {
-  const store = loadTriage(cwd);
-  const before = store.entries.length;
-  store.entries = store.entries.filter(e => !ids.some(id => e.id === id || e.id.startsWith(id)));
-  saveTriage(cwd, store);
-  return before - store.entries.length;
-}
-
-export function clearExpiredEntries(cwd: string): number {
-  const store = loadTriage(cwd);
-  const now = new Date().toISOString();
-  const before = store.entries.length;
-  store.entries = store.entries.filter(e => !e.expiresAt || e.expiresAt > now);
-  saveTriage(cwd, store);
-  return before - store.entries.length;
-}
-
-export interface TriageFilterResult {
-  active: Finding[];
-  triaged: Finding[];
-  triageCount: number;
-}
-
-export function filterTriaged(findings: Finding[], store: TriageStore): TriageFilterResult {
-  const now = new Date().toISOString();
-  const activeKeys = new Set(
-    store.entries
-      .filter(e => !e.expiresAt || e.expiresAt > now)
-      .map(entryKey),
-  );
-  const active: Finding[] = [];
-  const triaged: Finding[] = [];
-  for (const f of findings) {
-    if (activeKeys.has(entryKey(f))) triaged.push(f);
-    else active.push(f);
-  }
-  return { active, triaged, triageCount: triaged.length };
-}

package/src/core/phases/static-rules.ts

@@ -1,93 +0,0 @@
-import type { Finding, FixAttempt, FixStatus } from '../findings/types.ts';
-import type { GuardrailConfig } from '../config/types.ts';
-import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
-import { dedupFindings, findingContentKey } from '../findings/dedup.ts';
-
-export interface StaticRule {
-  name: string;
-  severity: 'critical' | 'warning' | 'note';
-  check(touchedFiles: string[], config?: Record<string, unknown>): Promise<Finding[]>;
-  autofix?(finding: Finding): Promise<FixStatus>;
-}
-
-export interface StaticRulesPhaseInput {
-  touchedFiles: string[];
-  rules: StaticRule[];
-  config?: GuardrailConfig;
-  engine?: ReviewEngine;
-}
-
-export interface StaticRulesPhaseResult {
-  phase: 'static-rules';
-  status: 'pass' | 'warn' | 'fail';
-  findings: Finding[];
-  fixAttempts: FixAttempt[];
-  durationMs: number;
-}
-
-export async function runStaticRulesPhase(input: StaticRulesPhaseInput): Promise<StaticRulesPhaseResult> {
-  const start = Date.now();
-
-  const preFixFindings = dedupFindings(await runAllChecks(input.rules, input.touchedFiles, input.config, input.engine));
-
-  const fixAttempts: FixAttempt[] = [];
-  let anyFixApplied = false;
-
-  for (const finding of preFixFindings) {
-    const rule = findRuleForFinding(input.rules, finding);
-    if (!rule?.autofix) continue;
-
-    if (finding.protectedPath) {
-      fixAttempts.push({
-        findingId: finding.id,
-        attemptedAt: new Date().toISOString(),
-        status: 'skipped',
-        notes: 'protected path',
-      });
-      continue;
-    }
-
-    const status = await rule.autofix(finding);
-    if (status === 'fixed') anyFixApplied = true;
-    fixAttempts.push({ findingId: finding.id, attemptedAt: new Date().toISOString(), status });
-  }
-
-  // Re-check is the source of truth for what persists after autofix.
-  // findings always returns preFixFindings so callers have a complete record;
-  // fixAttempts + re-check set-difference tells them what was resolved.
-  const postFixFindings = anyFixApplied
-    ? dedupFindings(await runAllChecks(input.rules, input.touchedFiles, input.config, input.engine))
-    : preFixFindings;
-
-  const postFixKeys = new Set(postFixFindings.map(findingContentKey));
-  const isFixed = (f: Finding): boolean => !postFixKeys.has(findingContentKey(f));
-
-  const unfixedCritical = preFixFindings.some(f => f.severity === 'critical' && !isFixed(f));
-  const unfixedWarning = preFixFindings.some(f => f.severity === 'warning' && !isFixed(f));
-
-  let status: StaticRulesPhaseResult['status'];
-  if (unfixedCritical) status = 'fail';
-  else if (unfixedWarning) status = 'warn';
-  else status = 'pass';
-
-  return { phase: 'static-rules', status, findings: preFixFindings, fixAttempts, durationMs: Date.now() - start };
-}
-
-async function runAllChecks(
-  rules: StaticRule[],
-  files: string[],
-  config?: GuardrailConfig,
-  engine?: ReviewEngine,
-): Promise<Finding[]> {
-  const ruleConfig: Record<string, unknown> = {
-    ...(config ? (config as unknown as Record<string, unknown>) : {}),
-    _engine: engine,
-  };
-  const all: Finding[] = [];
-  for (const rule of rules) all.push(...(await rule.check(files, ruleConfig)));
-  return all;
-}
-
-function findRuleForFinding(rules: StaticRule[], finding: Finding): StaticRule | undefined {
-  return rules.find(r => r.name === finding.category) ?? rules.find(r => finding.category.includes(r.name));
-}

package/src/core/phases/tests.ts

@@ -1,51 +0,0 @@
-import { execSync } from 'node:child_process';
-import type { Finding } from '../findings/types.ts';
-
-export interface TestsPhaseInput {
-  touchedFiles: string[];
-  testCommand?: string | null;
-  cwd?: string;
-}
-
-export interface TestsPhaseResult {
-  phase: 'tests';
-  status: 'pass' | 'fail' | 'skip';
-  findings: Finding[];
-  output?: string;
-  durationMs: number;
-}
-
-export async function runTestsPhase(input: TestsPhaseInput): Promise<TestsPhaseResult> {
-  const start = Date.now();
-
-  if (!input.testCommand) {
-    return { phase: 'tests', status: 'skip', findings: [], durationMs: Date.now() - start };
-  }
-
-  let output: string | undefined;
-  try {
-    // shell:true is intentional — testCommand is developer-supplied config, supports quoted args + pipes.
-    output = execSync(input.testCommand, {
-      encoding: 'utf8',
-      cwd: input.cwd,
-      timeout: 120000,
-      shell: process.env.SHELL ?? "/bin/sh",
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-  } catch {
-    const finding: Finding = {
-      id: 'tests-phase-fail',
-      source: 'static-rules',
-      severity: 'critical',
-      category: 'test-failure',
-      file: '<tests>',
-      message: `Test command failed: ${input.testCommand}`,
-      suggestion: 'Fix failing tests before merging',
-      protectedPath: false,
-      createdAt: new Date().toISOString(),
-    };
-    return { phase: 'tests', status: 'fail', findings: [finding], output: undefined, durationMs: Date.now() - start };
-  }
-
-  return { phase: 'tests', status: 'pass', findings: [], output, durationMs: Date.now() - start };
-}

package/src/core/pipeline/review-phase.ts

@@ -1,182 +0,0 @@
-import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
-import type { Finding } from '../findings/types.ts';
-import type { GuardrailConfig } from '../config/types.ts';
-import { buildReviewChunks, type ReviewChunk } from '../chunking/index.ts';
-import { GuardrailError } from '../errors.ts';
-import { hasFrontendFiles, loadDesignContext } from '../ui/design-context-loader.ts';
-
-export interface ReviewPhaseResult {
-  phase: 'review';
-  status: 'pass' | 'warn' | 'fail' | 'skip';
-  findings: Finding[];
-  rawOutputs?: string[];
-  costUSD?: number;
-  usage?: { input: number; output: number };
-  durationMs: number;
-}
-
-export interface ReviewPhaseInput {
-  touchedFiles: string[];
-  engine: ReviewEngine;
-  config: GuardrailConfig;
-  cwd?: string;
-  gitSummary?: string;
-  designSchema?: string;
-  budgetRemainingUSD?: number;
-  base?: string;
-}
-
-interface ChunkResult {
-  findings: Finding[];
-  rawOutput: string;
-  inputTokens: number;
-  outputTokens: number;
-  costUSD: number;
-}
-
-function backoffMs(attempt: number, strategy: 'exp' | 'linear' | 'none'): number {
-  if (strategy === 'none') return 0;
-  if (strategy === 'linear') return attempt * 2000;
-  return Math.min(Math.pow(2, attempt) * 1000, 32000); // exp: 1s, 2s, 4s, 8s … 32s cap
-}
-
-async function reviewChunkWithRetry(chunk: ReviewChunk, input: ReviewPhaseInput): Promise<ChunkResult> {
-  const strategy = input.config.chunking?.rateLimitBackoff ?? 'exp';
-  const maxAttempts = strategy === 'none' ? 1 : 4;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      const output = await input.engine.review({
-        content: chunk.content,
-        kind: chunk.kind,
-        context: { stack: input.config.stack, cwd: input.cwd, gitSummary: input.gitSummary, designSchema: input.designSchema },
-      });
-      return {
-        findings: output.findings,
-        rawOutput: output.rawOutput,
-        inputTokens: output.usage?.input ?? 0,
-        outputTokens: output.usage?.output ?? 0,
-        costUSD: output.usage?.costUSD ?? 0,
-      };
-    } catch (err) {
-      const isRateLimit = err instanceof GuardrailError && err.code === 'rate_limit';
-      const isLast = attempt === maxAttempts - 1;
-      if (!isRateLimit || isLast) throw err;
-      const delay = backoffMs(attempt + 1, strategy);
-      await new Promise(r => setTimeout(r, delay));
-    }
-  }
-  throw new Error('unreachable');
-}
-
-/** Run up to `limit` promises concurrently, preserving result order. */
-async function pMap<T, R>(
-  items: T[],
-  fn: (item: T, index: number) => Promise<R>,
-  limit: number,
-): Promise<R[]> {
-  const results: R[] = new Array(items.length);
-  let next = 0;
-
-  async function worker(): Promise<void> {
-    while (next < items.length) {
-      const i = next++;
-      results[i] = await fn(items[i]!, i);
-    }
-  }
-
-  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
-}
-
-export async function runReviewPhase(input: ReviewPhaseInput): Promise<ReviewPhaseResult> {
-  const start = Date.now();
-
-  if (input.touchedFiles.length === 0) {
-    return { phase: 'review', status: 'skip', findings: [], durationMs: Date.now() - start };
-  }
-
-  let designSchema: string | undefined;
-  if (hasFrontendFiles(input.touchedFiles) && input.config.brand?.componentLibrary) {
-    const loaded = loadDesignContext(
-      input.config.brand.componentLibrary,
-      input.cwd ?? process.cwd(),
-    );
-    if (loaded) designSchema = loaded;
-  }
-  const enrichedInput: ReviewPhaseInput = designSchema ? { ...input, designSchema } : input;
-
-  const chunks = await buildReviewChunks({
-    touchedFiles: enrichedInput.touchedFiles,
-    strategy: enrichedInput.config.reviewStrategy ?? 'auto',
-    chunking: enrichedInput.config.chunking,
-    engine: enrichedInput.engine,
-    cwd: enrichedInput.cwd,
-    protectedPaths: enrichedInput.config.protectedPaths,
-    base: enrichedInput.base,
-  });
-
-  const parallelism = enrichedInput.config.chunking?.parallelism ?? 3;
-  const budgetUSD = enrichedInput.budgetRemainingUSD;
-
-  // For budget tracking we still need to enforce it — run serially if budget set,
-  // parallel otherwise (budget check between serial chunks is the safe path).
-  let chunkResults: ChunkResult[];
-  if (budgetUSD !== undefined) {
-    chunkResults = [];
-    let spent = 0;
-    let budgetExceeded = false;
-    for (const chunk of chunks) {
-      if (spent >= budgetUSD) { budgetExceeded = true; break; }
-      const r = await reviewChunkWithRetry(chunk, enrichedInput);
-      spent += r.costUSD;
-      chunkResults.push(r);
-    }
-    if (budgetExceeded) {
-      chunkResults.push({
-        findings: [{
-          id: 'budget-exceeded',
-          source: 'pipeline',
-          severity: 'warning',
-          category: 'budget',
-          file: '<pipeline>',
-          message: `Review budget of $${budgetUSD} USD exceeded — remaining chunks skipped`,
-          protectedPath: false,
-          createdAt: new Date().toISOString(),
-        }],
-        rawOutput: '', inputTokens: 0, outputTokens: 0, costUSD: 0,
-      });
-    }
-  } else {
-    chunkResults = await pMap(chunks, chunk => reviewChunkWithRetry(chunk, enrichedInput), parallelism);
-  }
-
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let totalCostUSD = 0;
-  const allFindings: Finding[] = [];
-  const allRawOutputs: string[] = [];
-
-  for (const r of chunkResults) {
-    allFindings.push(...r.findings);
-    if (r.rawOutput) allRawOutputs.push(r.rawOutput);
-    totalInputTokens += r.inputTokens;
-    totalOutputTokens += r.outputTokens;
-    totalCostUSD += r.costUSD;
-  }
-
-  const hasCritical = allFindings.some(f => f.severity === 'critical');
-  const hasWarning = allFindings.some(f => f.severity === 'warning');
-  const status = hasCritical ? 'fail' : hasWarning ? 'warn' : 'pass';
-
-  return {
-    phase: 'review',
-    status,
-    findings: allFindings,
-    rawOutputs: allRawOutputs.length > 0 ? allRawOutputs : undefined,
-    costUSD: totalCostUSD > 0 ? totalCostUSD : undefined,
-    usage: totalInputTokens > 0 ? { input: totalInputTokens, output: totalOutputTokens } : undefined,
-    durationMs: Date.now() - start,
-  };
-}