@delegance/claude-autopilot 5.0.1 → 5.0.2

package/src/core/pipeline/run.ts

@@ -1,116 +0,0 @@
-import type { GuardrailConfig } from '../config/types.ts';
-import type { StaticRule } from '../phases/static-rules.ts';
-import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
-import type { Finding } from '../findings/types.ts';
-import type { StaticRulesPhaseResult } from '../phases/static-rules.ts';
-import type { TestsPhaseResult } from '../phases/tests.ts';
-import type { ReviewPhaseResult } from './review-phase.ts';
-import { runStaticRulesPhase } from '../phases/static-rules.ts';
-import { runTestsPhase } from '../phases/tests.ts';
-import { runReviewPhase } from './review-phase.ts';
-
-export type PhaseResult = StaticRulesPhaseResult | TestsPhaseResult | ReviewPhaseResult;
-
-export interface RunInput {
-  touchedFiles: string[];
-  config: GuardrailConfig;
-  reviewEngine?: ReviewEngine;
-  staticRules?: StaticRule[];
-  cwd?: string;
-  gitSummary?: string;
-  base?: string;
-  skipReview?: boolean;
-}
-
-export interface RunResult {
-  status: 'pass' | 'warn' | 'fail';
-  phases: PhaseResult[];
-  allFindings: Finding[];
-  totalCostUSD?: number;
-  durationMs: number;
-}
-
-export async function runGuardrail(input: RunInput): Promise<RunResult> {
-  const start = Date.now();
-  const phases: PhaseResult[] = [];
-  let totalCostUSD: number | undefined;
-
-  const pipelineCfg = input.config.pipeline ?? {};
-  // Default true: when the user wires up a review engine they expect it to actually run.
-  // Skipping LLM review on static-fail is exactly the "silent skip" behavior the v4.0
-  // reviewer flagged — the bugs the LLM is best at often ride alongside one a static
-  // rule already caught.
-  const runReviewOnStaticFail = pipelineCfg.runReviewOnStaticFail !== false;
-  const runReviewOnTestFail = pipelineCfg.runReviewOnTestFail === true;
-
-  // Static-rules phase — tests always run afterward, regardless of status. The
-  // runReviewOnStaticFail flag only gates the LLM review phase (matching its name);
-  // skipping tests on a static-fail would be surprising and asymmetric with
-  // runReviewOnTestFail which only gates the review phase too.
-  let staticFailed = false;
-  if (input.staticRules && input.staticRules.length > 0) {
-    const result = await runStaticRulesPhase({
-      touchedFiles: input.touchedFiles,
-      rules: input.staticRules,
-      config: input.config,
-      engine: input.reviewEngine,
-    });
-    phases.push(result);
-    staticFailed = result.status === 'fail';
-  }
-
-  // skipReview short-circuit: skip tests and review phases entirely
-  if (input.skipReview) {
-    const allFindings = phases.flatMap(p => p.findings ?? []);
-    const hasCritical = allFindings.some(f => f.severity === 'critical');
-    return {
-      status: hasCritical ? 'fail' : 'pass',
-      phases,
-      allFindings,
-      totalCostUSD: undefined,
-      durationMs: Date.now() - start,
-    };
-  }
-
-  // Tests phase — always runs (unless skipReview above). The runReviewOnTestFail
-  // flag only gates the subsequent review phase.
-  const testsResult = await runTestsPhase({
-    touchedFiles: input.touchedFiles,
-    testCommand: input.config.testCommand,
-    cwd: input.cwd,
-  });
-  phases.push(testsResult);
-  const testsFailed = testsResult.status === 'fail';
-
-  // Review phase (optional — only when engine is provided, not gated off by flags)
-  const skipReviewDueToStatic = staticFailed && !runReviewOnStaticFail;
-  const skipReviewDueToTests = testsFailed && !runReviewOnTestFail;
-  if (input.reviewEngine && !skipReviewDueToStatic && !skipReviewDueToTests) {
-    const costCfg = input.config.cost as { maxPerRun?: number; budgetUSD?: number } | undefined;
-    const budgetUSD = costCfg?.maxPerRun ?? costCfg?.budgetUSD;
-    const reviewResult = await runReviewPhase({
-      touchedFiles: input.touchedFiles,
-      engine: input.reviewEngine,
-      config: input.config,
-      cwd: input.cwd,
-      gitSummary: input.gitSummary,
-      budgetRemainingUSD: budgetUSD,
-      base: input.base,
-    });
-    phases.push(reviewResult);
-    if (reviewResult.costUSD !== undefined) {
-      totalCostUSD = (totalCostUSD ?? 0) + reviewResult.costUSD;
-    }
-  }
-
-  return finalize(phases, start, totalCostUSD);
-}
-
-function finalize(phases: PhaseResult[], start: number, totalCostUSD: number | undefined): RunResult {
-  const allFindings: Finding[] = phases.flatMap(p => p.findings);
-  // Trust each phase's own status — it accounts for autofixes and dedup
-  const anyFail = phases.some(p => p.status === 'fail');
-  const anyWarn = phases.some(p => p.status === 'warn');
-  const status: RunResult['status'] = anyFail ? 'fail' : anyWarn ? 'warn' : 'pass';
-  return { status, phases, allFindings, totalCostUSD, durationMs: Date.now() - start };
-}

package/src/core/runtime/idempotency.ts

@@ -1,6 +0,0 @@
-import { createHash } from 'node:crypto';
-
-export function idempotencyKey(runId: string, step: string, inputs: Record<string, unknown>): string {
-  const serialized = JSON.stringify({ runId, step, inputs });
-  return createHash('sha256').update(serialized).digest('hex').slice(0, 16);
-}

package/src/core/runtime/lock.ts

@@ -1,29 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { GuardrailError } from '../errors.ts';
-
-export interface LockHandle {
-  release(): Promise<void>;
-}
-
-export function acquireLock(runId: string, lockDir = '.claude'): LockHandle {
-  fs.mkdirSync(lockDir, { recursive: true });
-  const lockPath = path.join(lockDir, '.lock');
-  try {
-    fs.writeFileSync(
-      lockPath,
-      JSON.stringify({ runId, pid: process.pid, acquiredAt: new Date().toISOString() }),
-      { flag: 'wx' }
-    );
-  } catch (err) {
-    throw new GuardrailError('Another autopilot run holds the lock', {
-      code: 'concurrency_lock',
-      details: { lockPath, cause: err instanceof Error ? err.message : String(err) },
-    });
-  }
-  return {
-    release: async () => {
-      try { await fs.promises.unlink(lockPath); } catch { /* best effort */ }
-    },
-  };
-}

package/src/core/runtime/state.ts

@@ -1,97 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { GuardrailError } from '../errors.ts';
-
-export type PipelineStep =
-  | 'plan' | 'worktree' | 'implement' | 'migrate' | 'validate'
-  | 'push' | 'create-pr' | 'review' | 'bugbot';
-
-export type StepStatus = 'pending' | 'in-progress' | 'completed' | 'failed' | 'skipped';
-export type RunStatus = 'in-progress' | 'completed' | 'failed' | 'superseded';
-
-export interface StepState {
-  status: StepStatus;
-  idempotencyKey?: string;
-  artifact?: string;
-  errorCode?: string;
-  attempts?: number;
-  lastCommitSha?: string;
-  appliedMigrations?: string[];
-  prNumber?: number;
-  alreadyExisted?: boolean;
-}
-
-export interface RunState {
-  runId: string;
-  topic: string;
-  startedAt: string;
-  lastUpdatedAt: string;
-  status: RunStatus;
-  currentStep: PipelineStep | null;
-  steps: Record<PipelineStep, StepState>;
-}
-
-export const ALL_STEPS: readonly PipelineStep[] = Object.freeze([
-  'plan', 'worktree', 'implement', 'migrate', 'validate', 'push', 'create-pr', 'review', 'bugbot',
-]);
-
-function stateFile(runId: string, runsDir: string): string {
-  return path.join(runsDir, runId, 'state.json');
-}
-
-async function writeAtomic(file: string, content: string): Promise<void> {
-  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  await fs.writeFile(tmp, content, 'utf8');
-  await fs.rename(tmp, file);
-}
-
-export interface CreateRunStateOptions {
-  runId: string;
-  topic: string;
-  runsDir?: string;
-}
-
-export async function createRunState(options: CreateRunStateOptions): Promise<RunState> {
-  const runsDir = options.runsDir ?? path.join('.claude', 'runs');
-  await fs.mkdir(path.join(runsDir, options.runId), { recursive: true });
-  const now = new Date().toISOString();
-  const stepsInit = {} as Record<PipelineStep, StepState>;
-  for (const step of ALL_STEPS) stepsInit[step] = { status: 'pending' };
-  const state: RunState = {
-    runId: options.runId, topic: options.topic,
-    startedAt: now, lastUpdatedAt: now,
-    status: 'in-progress', currentStep: null, steps: stepsInit,
-  };
-  await writeAtomic(stateFile(options.runId, runsDir), JSON.stringify(state, null, 2));
-  return state;
-}
-
-export async function loadRunState(runId: string, runsDir?: string): Promise<RunState> {
-  const dir = runsDir ?? path.join('.claude', 'runs');
-  const file = stateFile(runId, dir);
-  try {
-    return JSON.parse(await fs.readFile(file, 'utf8')) as RunState;
-  } catch (err) {
-    throw new GuardrailError(`Run state not found: ${runId}`, {
-      code: 'user_input',
-      details: { runId, file, cause: err instanceof Error ? err.message : String(err) },
-    });
-  }
-}
-
-export interface UpdateStepOptions {
-  runId: string;
-  runsDir?: string;
-  step: PipelineStep;
-  update: Partial<StepState>;
-}
-
-export async function updateStepStatus(options: UpdateStepOptions): Promise<RunState> {
-  const runsDir = options.runsDir ?? path.join('.claude', 'runs');
-  const state = await loadRunState(options.runId, runsDir);
-  state.steps[options.step] = { ...state.steps[options.step], ...options.update };
-  state.lastUpdatedAt = new Date().toISOString();
-  if (options.update.status === 'in-progress') state.currentStep = options.step;
-  await writeAtomic(stateFile(options.runId, runsDir), JSON.stringify(state, null, 2));
-  return state;
-}

package/src/core/schema-alignment/detector.ts

@@ -1,59 +0,0 @@
-// src/core/schema-alignment/detector.ts
-import type { SchemaAlignmentConfig } from './types.ts';
-
-const DEFAULT_PATTERNS: RegExp[] = [
-  /data[/\\]deltas[/\\].+\.sql$/,
-  /supabase[/\\]migrations[/\\].+\.sql$/,
-  /prisma[/\\]migrations[/\\].+\.sql$/,
-  /prisma[/\\]schema\.prisma$/,
-  /db[/\\]migrate[/\\].+\.rb$/,
-  /drizzle[/\\].+\.ts$/,
-  /[/\\]migrations[/\\].+\.py$/,
-];
-
-function globToPattern(glob: string): RegExp {
-  let escaped = glob;
-
-  // Escape regex special chars except * and /
-  escaped = escaped.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-
-  // Replace **/ with placeholder (matches zero or more intermediate directories)
-  escaped = escaped.replace(/\*\*\//g, '___DSTAR_SLASH___');
-
-  // Replace remaining ** with placeholder
-  escaped = escaped.replace(/\*\*/g, '___DSTAR___');
-
-  // Replace / with placeholder BEFORE handling * so we don't mess up character classes
-  escaped = escaped.replace(/\//g, '___SLASH___');
-
-  // Replace single * with placeholder (to preserve it before / restoration)
-  escaped = escaped.replace(/\*/g, '___STAR___');
-
-  // Now restore placeholders in the right order
-  // Restore / as [/\\\\] to match both forward and back slashes
-  // NOTE: In RegExp constructor, \\ becomes \, so [/\\] needs to be [/\\\\]
-  escaped = escaped.replace(/___SLASH___/g, '[/\\\\]');
-
-  // Restore * as [^/]* (matches anything except /)
-  escaped = escaped.replace(/___STAR___/g, '[^/]*');
-
-  // Restore **/ as optional directory segments with trailing separator
-  escaped = escaped.replace(/___DSTAR_SLASH___/g, '(?:.*[/\\\\])?');
-
-  // Restore remaining ** as .* (matches anything including /)
-  escaped = escaped.replace(/___DSTAR___/g, '.*');
-
-  const re = new RegExp(escaped + '$');
-  return re;
-}
-
-export function detect(touchedFiles: string[], config?: SchemaAlignmentConfig): string[] {
-  if (config?.enabled === false) return [];
-
-  const patterns = [...DEFAULT_PATTERNS];
-  for (const glob of config?.migrationGlobs ?? []) {
-    patterns.push(globToPattern(glob));
-  }
-
-  return touchedFiles.filter(f => patterns.some(re => re.test(f)));
-}

package/src/core/schema-alignment/extractor/index.ts

@@ -1,24 +0,0 @@
-// src/core/schema-alignment/extractor/index.ts
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { SchemaEntity } from '../types.ts';
-import { extractFromSql } from './sql.ts';
-import { extractFromPrisma } from './prisma.ts';
-
-export function extract(filePath: string): SchemaEntity[] {
-  let content: string;
-  try {
-    content = fs.readFileSync(filePath, 'utf8');
-  } catch {
-    return [];
-  }
-
-  const ext = path.extname(filePath).toLowerCase();
-  const base = path.basename(filePath).toLowerCase();
-
-  if (ext === '.sql') return extractFromSql(content);
-  if (base === 'schema.prisma' || ext === '.prisma') return extractFromPrisma(content);
-
-  process.stderr.write(`[schema-alignment] no extractor for ${ext} files — skipping ${path.basename(filePath)}\n`);
-  return [];
-}

package/src/core/schema-alignment/extractor/prisma.ts

@@ -1,21 +0,0 @@
-// src/core/schema-alignment/extractor/prisma.ts
-import type { SchemaEntity } from '../types.ts';
-
-export function extractFromPrisma(content: string): SchemaEntity[] {
-  const entities: SchemaEntity[] = [];
-  // Match model blocks: model Name { ... }
-  const modelRe = /^model\s+(\w+)\s*\{([^}]+)\}/gm;
-  for (const modelMatch of content.matchAll(modelRe)) {
-    const table = modelMatch[1]!;
-    entities.push({ table, operation: 'create_table' });
-    const body = modelMatch[2]!;
-    // Match field lines: fieldName TypeName ...
-    const fieldRe = /^\s+(\w+)\s+\S/gm;
-    for (const fieldMatch of body.matchAll(fieldRe)) {
-      const column = fieldMatch[1]!;
-      if (column.startsWith('@') || column === 'id') continue;
-      entities.push({ table, column, operation: 'add_column' });
-    }
-  }
-  return entities;
-}

package/src/core/schema-alignment/extractor/sql.ts

@@ -1,99 +0,0 @@
-// src/core/schema-alignment/extractor/sql.ts
-import type { SchemaEntity } from '../types.ts';
-
-function unquote(s: string | undefined): string {
-  if (!s) return '';
-  return s.replace(/^["'`]|["'`]$/g, '');
-}
-
-// Identifier: quoted or unquoted word (no schema prefix captured)
-const ID = /(?:"([^"]+)"|`([^`]+)`|(\w+))/;
-const SCHEMA_OPT = /(?:\w+\.)?/;
-
-// Keywords that can follow ADD/DROP but are NOT columns
-const NON_COLUMN_KEYWORDS = new Set([
-  'CONSTRAINT', 'INDEX', 'PRIMARY', 'FOREIGN', 'UNIQUE', 'CHECK',
-  'KEY', 'EXCLUDE', 'REFERENCES',
-]);
-
-export function extractFromSql(content: string): SchemaEntity[] {
-  // Strip comments before processing
-  const normalized = content
-    .replace(/--[^\n]*/g, ' ')
-    .replace(/\/\*[\s\S]*?\*\//g, ' ')
-    .replace(/\s+/g, ' ');
-
-  const entities: SchemaEntity[] = [];
-
-  // CREATE TABLE [IF NOT EXISTS] [schema.]name
-  const createTableRe = new RegExp(
-    `CREATE\\s+(?:OR\\s+REPLACE\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?${SCHEMA_OPT.source}${ID.source}`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(createTableRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    if (table && table.toUpperCase() !== 'EXISTS') entities.push({ table, operation: 'create_table' });
-  }
-
-  // ALTER TABLE [schema.]name ADD [COLUMN] [IF NOT EXISTS] col
-  const addColRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(?:ONLY\\s+)?${SCHEMA_OPT.source}${ID.source}\\s+ADD\\s+(?:COLUMN\\s+)?(?:IF\\s+NOT\\s+EXISTS\\s+)?${ID.source}`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(addColRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    const column = unquote(m[4] ?? m[5] ?? m[6]);
-    if (!table || !column) continue;
-    // Skip non-column ADD operations (CONSTRAINT, INDEX, PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK)
-    if (NON_COLUMN_KEYWORDS.has(column.toUpperCase())) continue;
-    entities.push({ table, column, operation: 'add_column' });
-  }
-
-  // ALTER TABLE [schema.]name DROP [COLUMN] [IF EXISTS] col
-  const dropColRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(?:ONLY\\s+)?${SCHEMA_OPT.source}${ID.source}\\s+DROP\\s+(?:COLUMN\\s+)?(?:IF\\s+EXISTS\\s+)?${ID.source}`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(dropColRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    const column = unquote(m[4] ?? m[5] ?? m[6]);
-    if (!table || !column) continue;
-    // Skip non-column DROP operations (CONSTRAINT, INDEX, PRIMARY KEY, FOREIGN KEY)
-    if (NON_COLUMN_KEYWORDS.has(column.toUpperCase())) continue;
-    entities.push({ table, column, operation: 'drop_column' });
-  }
-
-  // ALTER TABLE [schema.]name RENAME [COLUMN] old TO new
-  const renameColRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(?:ONLY\\s+)?${SCHEMA_OPT.source}${ID.source}\\s+RENAME\\s+(?:COLUMN\\s+)?${ID.source}\\s+TO\\s+${ID.source}`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(renameColRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    const oldName = unquote(m[4] ?? m[5] ?? m[6]);
-    const column = unquote(m[7] ?? m[8] ?? m[9]);
-    if (table && column) entities.push({ table, column, operation: 'rename_column', oldName });
-  }
-
-  // CREATE TYPE [schema.]name
-  const createTypeRe = new RegExp(
-    `CREATE\\s+TYPE\\s+${SCHEMA_OPT.source}${ID.source}`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(createTypeRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    if (table) entities.push({ table, operation: 'create_type' });
-  }
-
-  // ALTER TYPE [schema.]name ADD VALUE ...
-  const alterTypeRe = new RegExp(
-    `ALTER\\s+TYPE\\s+${SCHEMA_OPT.source}${ID.source}\\s+ADD\\s+VALUE`,
-    'gi',
-  );
-  for (const m of normalized.matchAll(alterTypeRe)) {
-    const table = unquote(m[1] ?? m[2] ?? m[3]);
-    if (table) entities.push({ table, operation: 'create_type' });
-  }
-
-  return entities;
-}

package/src/core/schema-alignment/llm-check.ts

@@ -1,91 +0,0 @@
-// src/core/schema-alignment/llm-check.ts
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
-import type { SchemaEntity, LayerScanResult, AlignmentFinding } from './types.ts';
-
-const TOTAL_CHAR_BUDGET = 6000;
-
-function truncateTop(text: string, maxChars: number): string {
-  if (text.length <= maxChars) return text;
-  const dropped = text.length - maxChars;
-  return `<!-- [schema-alignment: truncated ${dropped} chars] -->\n` + text.slice(dropped);
-}
-
-export async function runLlmCheck(
-  migrationFiles: string[],
-  gapResults: LayerScanResult[],
-  engine: ReviewEngine,
-): Promise<AlignmentFinding[]> {
-  let budget = TOTAL_CHAR_BUDGET;
-  const migrationSnippets: string[] = [];
-
-  for (const f of migrationFiles) {
-    if (budget <= 0) break;
-    let content: string;
-    try { content = fs.readFileSync(f, 'utf8'); } catch { continue; }
-    const snippet = truncateTop(content, Math.floor(budget * 0.6));
-    migrationSnippets.push(`### Migration: ${path.basename(f)}\n\`\`\`sql\n${snippet}\n\`\`\``);
-    budget -= snippet.length;
-  }
-
-  const entitySummary = gapResults.map(r => {
-    const isDestructive = r.entity.operation === 'drop_column' || r.entity.operation === 'rename_column';
-    const gaps = isDestructive
-      ? [r.typeLayer, r.apiLayer, r.uiLayer]
-          .map((e, i) => e !== null ? (['type', 'api', 'ui'][i]) : null)
-          .filter(Boolean).join(', ')
-      : [r.typeLayer === null ? 'type' : null, r.apiLayer === null ? 'api' : null, r.uiLayer === null ? 'ui' : null]
-          .filter(Boolean).join(', ');
-    return `- ${r.entity.operation} ${r.entity.table}${r.entity.column ? '.' + r.entity.column : ''}: ${isDestructive ? 'stale ref in' : 'missing in'} [${gaps}]`;
-  }).join('\n');
-
-  const prompt = [
-    'You are reviewing schema-layer alignment for a software project.',
-    '',
-    migrationSnippets.length > 0
-      ? `The following migration files were changed:\n\n${migrationSnippets.join('\n\n')}`
-      : '(no readable migration files)',
-    '',
-    `The structural scan found these potential alignment gaps:\n${entitySummary || '(none)'}`,
-    '',
-    'For each gap, determine if it is a real problem. Return findings as a JSON array:',
-    '[{ "table": "name", "column": "name_or_null", "operation": "add_column", "layer": "type", "file": "path/to/relevant/file.ts (optional)", "message": "explanation", "severity": "warning", "confidence": "high" }]',
-    'Return only valid JSON, no prose.',
-  ].join('\n');
-
-  let rawOutput: string;
-  try {
-    const result = await engine.review({ content: prompt, kind: 'file-batch' });
-    rawOutput = result.rawOutput;
-  } catch {
-    return [];
-  }
-
-  const jsonMatch = rawOutput.match(/\[[\s\S]*\]/);
-  if (!jsonMatch) return [];
-
-  try {
-    const parsed = JSON.parse(jsonMatch[0]) as Array<{
-      table: string; column?: string; operation: string;
-      layer: string; message: string; severity: string; confidence: string;
-      file?: string;
-    }>;
-    return parsed
-      .filter(item => item.table && item.layer && item.message)
-      .map(item => ({
-        entity: {
-          table: item.table,
-          column: item.column,
-          operation: item.operation as SchemaEntity['operation'],
-        },
-        layer: item.layer as AlignmentFinding['layer'],
-        message: item.message,
-        file: item.file,
-        severity: (item.severity === 'error' ? 'error' : 'warning') as AlignmentFinding['severity'],
-        confidence: (['high', 'medium', 'low'].includes(item.confidence) ? item.confidence : 'medium') as AlignmentFinding['confidence'],
-      }));
-  } catch {
-    return [];
-  }
-}

package/src/core/schema-alignment/scanner.ts

@@ -1,107 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import type { SchemaEntity, Evidence, LayerScanResult, SchemaAlignmentConfig } from './types.ts';
-
-const DEFAULT_ROOTS = {
-  types: ['types/', 'src/types/', 'lib/types/'],
-  api: ['app/api/', 'lib/', 'services/', 'src/routes/'],
-  ui: ['app/', 'src/', 'components/'],
-};
-
-function* walkFiles(dir: string): Generator<string> {
-  if (!fs.existsSync(dir)) return;
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
-      if (IGNORED_DIRS.has(entry.name)) continue;
-      yield* walkFiles(path.join(dir, entry.name));
-    } else if (entry.isFile()) {
-      const ext = path.extname(entry.name).toLowerCase();
-      if (CODE_EXTS.has(ext)) yield path.join(dir, entry.name);
-    }
-  }
-}
-
-const IGNORED_DIRS = new Set([
-  'node_modules', '.next', 'dist', 'build', 'coverage', '.git',
-  '.turbo', '.cache', '.vercel', 'out', '.nuxt', 'target',
-]);
-
-const CODE_EXTS = new Set([
-  '.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs',
-  '.vue', '.svelte', '.astro', '.py', '.rb', '.go', '.rs',
-]);
-
-function resolveRoots(roots: string[], cwd: string): string[] {
-  return roots.map(r => path.isAbsolute(r) ? r : path.join(cwd, r));
-}
-
-function isUnder(filePath: string, dir: string): boolean {
-  const rel = path.relative(dir, filePath);
-  return !rel.startsWith('..') && !path.isAbsolute(rel);
-}
-
-function searchLayer(
-  roots: string[],
-  pattern: RegExp,
-  cwd: string,
-  excludedDirs: string[] = [],
-): Evidence | null {
-  for (const root of roots) {
-    const dir = path.isAbsolute(root) ? root : path.join(cwd, root);
-    for (const filePath of walkFiles(dir)) {
-      // Skip files that belong to an excluded layer's root (avoids UI root
-      // `app/` reporting API evidence from `app/api/`, etc.)
-      if (excludedDirs.some(excl => isUnder(filePath, excl))) continue;
-      let content: string;
-      try { content = fs.readFileSync(filePath, 'utf8'); } catch { continue; }
-      const lines = content.split('\n');
-      for (let i = 0; i < lines.length; i++) {
-        if (pattern.test(lines[i]!)) {
-          return {
-            file: filePath,
-            line: i + 1,
-            snippet: lines[i]!.trim().slice(0, 120),
-            confidence: 'high',
-          };
-        }
-      }
-    }
-  }
-  return null;
-}
-
-function escapeRe(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export function scanLayers(
-  entities: SchemaEntity[],
-  cwd: string,
-  config?: SchemaAlignmentConfig,
-): LayerScanResult[] {
-  const roots = {
-    types: config?.layerRoots?.types ?? DEFAULT_ROOTS.types,
-    api: config?.layerRoots?.api ?? DEFAULT_ROOTS.api,
-    ui: config?.layerRoots?.ui ?? DEFAULT_ROOTS.ui,
-  };
-  const resolvedTypeRoots = resolveRoots(roots.types, cwd);
-  const resolvedApiRoots = resolveRoots(roots.api, cwd);
-
-  return entities.map(entity => {
-    const isDestructive = entity.operation === 'drop_column' || entity.operation === 'rename_column';
-    const searchName = isDestructive
-      ? (entity.oldName ?? entity.column ?? entity.table)
-      : (entity.column ?? entity.table);
-
-    const pattern = new RegExp(`\\b${escapeRe(searchName)}\\b`);
-
-    return {
-      entity,
-      typeLayer: searchLayer(roots.types, pattern, cwd),
-      // API search excludes type roots (prevents lib/ from picking up lib/types/ matches)
-      apiLayer: searchLayer(roots.api, pattern, cwd, resolvedTypeRoots),
-      // UI search excludes both type and API roots (prevents app/ from picking up app/api/)
-      uiLayer: searchLayer(roots.ui, pattern, cwd, [...resolvedTypeRoots, ...resolvedApiRoots]),
-    };
-  });
-}