@delegance/claude-autopilot 1.0.0-alpha.4

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

@@ -0,0 +1,87 @@
+import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
+import type { Finding } from '../findings/types.ts';
+import type { AutopilotConfig } from '../config/types.ts';
+import { buildReviewChunks } from '../chunking/index.ts';
+
+export interface ReviewPhaseResult {
+  phase: 'review';
+  status: 'pass' | 'warn' | 'fail' | 'skip';
+  findings: Finding[];
+  costUSD?: number;
+  usage?: { input: number; output: number };
+  durationMs: number;
+}
+
+export interface ReviewPhaseInput {
+  touchedFiles: string[];
+  engine: ReviewEngine;
+  config: AutopilotConfig;
+  cwd?: string;
+  budgetRemainingUSD?: number;
+}
+
+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 };
+  }
+
+  const chunks = await buildReviewChunks({
+    touchedFiles: input.touchedFiles,
+    strategy: input.config.reviewStrategy ?? 'auto',
+    chunking: input.config.chunking,
+    engine: input.engine,
+    cwd: input.cwd,
+  });
+
+  const allFindings: Finding[] = [];
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCostUSD = 0;
+  let budgetExceeded = false;
+
+  for (const chunk of chunks) {
+    if (input.budgetRemainingUSD !== undefined && totalCostUSD >= input.budgetRemainingUSD) {
+      budgetExceeded = true;
+      break;
+    }
+    const output = await input.engine.review({
+      content: chunk.content,
+      kind: chunk.kind,
+      context: { stack: input.config.stack },
+    });
+    allFindings.push(...output.findings);
+    if (output.usage) {
+      totalInputTokens += output.usage.input;
+      totalOutputTokens += output.usage.output;
+      if (output.usage.costUSD !== undefined) totalCostUSD += output.usage.costUSD;
+    }
+  }
+
+  if (budgetExceeded) {
+    allFindings.push({
+      id: 'budget-exceeded',
+      source: 'pipeline',
+      severity: 'warning',
+      category: 'budget',
+      file: '<pipeline>',
+      message: `Review budget of $${input.budgetRemainingUSD} USD exceeded — remaining chunks skipped`,
+      protectedPath: false,
+      createdAt: new Date().toISOString(),
+    });
+  }
+
+  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,
+    costUSD: totalCostUSD > 0 ? totalCostUSD : undefined,
+    usage: totalInputTokens > 0 ? { input: totalInputTokens, output: totalOutputTokens } : undefined,
+    durationMs: Date.now() - start,
+  };
+}

package/src/core/pipeline/run.ts

@@ -0,0 +1,80 @@
+import type { AutopilotConfig } 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: AutopilotConfig;
+  reviewEngine?: ReviewEngine;
+  staticRules?: StaticRule[];
+  cwd?: string;
+}
+
+export interface RunResult {
+  status: 'pass' | 'warn' | 'fail';
+  phases: PhaseResult[];
+  allFindings: Finding[];
+  totalCostUSD?: number;
+  durationMs: number;
+}
+
+export async function runAutopilot(input: RunInput): Promise<RunResult> {
+  const start = Date.now();
+  const phases: PhaseResult[] = [];
+  let totalCostUSD: number | undefined;
+
+  // Static-rules phase — fail fast on critical
+  if (input.staticRules && input.staticRules.length > 0) {
+    const result = await runStaticRulesPhase({
+      touchedFiles: input.touchedFiles,
+      rules: input.staticRules,
+    });
+    phases.push(result);
+    if (result.status === 'fail') return finalize(phases, start, totalCostUSD);
+  }
+
+  // Tests phase — fail fast on test failure
+  const testsResult = await runTestsPhase({
+    touchedFiles: input.touchedFiles,
+    testCommand: input.config.testCommand,
+    cwd: input.cwd,
+  });
+  phases.push(testsResult);
+  if (testsResult.status === 'fail') return finalize(phases, start, totalCostUSD);
+
+  // Review phase (optional — only when engine is provided)
+  if (input.reviewEngine) {
+    const budgetUSD = (input.config.cost as { budgetUSD?: number } | undefined)?.budgetUSD;
+    const reviewResult = await runReviewPhase({
+      touchedFiles: input.touchedFiles,
+      engine: input.reviewEngine,
+      config: input.config,
+      cwd: input.cwd,
+      budgetRemainingUSD: budgetUSD,
+    });
+    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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,29 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { AutopilotError } 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 AutopilotError('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

@@ -0,0 +1,97 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { AutopilotError } 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 AutopilotError(`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/shell.ts

@@ -0,0 +1,48 @@
+// src/core/shell.ts
+
+import { execFileSync } from 'node:child_process';
+import { AutopilotError, type ErrorCode } from './errors.ts';
+
+export interface RunOptions {
+  timeout?: number;
+  input?: string;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+/** Run a command; return stdout on success, null on any failure. Never throws. */
+export function runSafe(cmd: string, args: string[], options: RunOptions = {}): string | null {
+  try {
+    const result = execFileSync(cmd, args, {
+      encoding: 'utf8',
+      stdio: options.input ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+      timeout: options.timeout ?? 60000,
+      input: options.input,
+      cwd: options.cwd,
+      env: options.env,
+    });
+    return result.toString();
+  } catch {
+    return null;
+  }
+}
+
+/** Run a command; throw AutopilotError on failure. */
+export function runThrowing(cmd: string, args: string[], options: RunOptions & { errorCode?: ErrorCode; provider?: string } = {}): string {
+  try {
+    return execFileSync(cmd, args, {
+      encoding: 'utf8',
+      stdio: options.input ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+      timeout: options.timeout ?? 60000,
+      input: options.input,
+      cwd: options.cwd,
+      env: options.env,
+    }).toString();
+  } catch (err) {
+    throw new AutopilotError(`Command failed: ${cmd} ${args.join(' ')}`, {
+      code: options.errorCode ?? 'transient_network',
+      provider: options.provider,
+      details: { cmd, args, cause: err instanceof Error ? err.message : String(err) },
+    });
+  }
+}