@delegance/claude-autopilot 1.0.0-alpha.4

package/src/core/chunking/index.ts

@@ -0,0 +1,82 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { ReviewEngine, ReviewInput } from '../../adapters/review-engine/types.ts';
+import type { AutopilotConfig } from '../config/types.ts';
+
+export interface ReviewChunk {
+  content: string;
+  kind: ReviewInput['kind'];
+  files: string[];
+}
+
+export interface BuildChunksInput {
+  touchedFiles: string[];
+  strategy: 'auto' | 'single-pass' | 'file-level';
+  chunking?: AutopilotConfig['chunking'];
+  engine: ReviewEngine;
+  cwd?: string;
+}
+
+const DEFAULT_SMALL_TIER_TOKENS = 8000;
+const DEFAULT_FILE_TIER_TOKENS = 60000;
+
+export async function buildReviewChunks(input: BuildChunksInput): Promise<ReviewChunk[]> {
+  const smallMax = input.chunking?.smallTierMaxTokens ?? DEFAULT_SMALL_TIER_TOKENS;
+  const fileMax = input.chunking?.perFileMaxTokens ?? DEFAULT_FILE_TIER_TOKENS;
+
+  const fileContents = await readFiles(input.touchedFiles, input.cwd);
+
+  if (input.strategy === 'single-pass') {
+    const combined = formatBatch(fileContents);
+    return [{ content: combined, kind: 'file-batch', files: [...fileContents.keys()] }];
+  }
+
+  if (input.strategy === 'auto') {
+    const combined = formatBatch(fileContents);
+    if (input.engine.estimateTokens(combined) <= smallMax) {
+      return [{ content: combined, kind: 'file-batch', files: [...fileContents.keys()] }];
+    }
+    // fall through to file-level
+  }
+
+  // file-level: one chunk per readable file, truncated to fileMax tokens
+  const chunks: ReviewChunk[] = [];
+  for (const [filePath, content] of fileContents) {
+    const truncated = truncateToTokens(content, fileMax, input.engine);
+    chunks.push({ content: `// File: ${filePath}\n${truncated}`, kind: 'file-batch', files: [filePath] });
+  }
+  return chunks;
+}
+
+async function readFiles(touchedFiles: string[], cwd?: string): Promise<Map<string, string>> {
+  const result = new Map<string, string>();
+  for (const f of touchedFiles) {
+    const resolved = cwd ? path.resolve(cwd, f) : path.resolve(f);
+    try {
+      result.set(f, await fs.readFile(resolved, 'utf8'));
+    } catch {
+      // deleted or unreadable — skip silently
+    }
+  }
+  return result;
+}
+
+function formatBatch(fileContents: Map<string, string>): string {
+  const parts: string[] = [];
+  for (const [filePath, content] of fileContents) {
+    parts.push(`// File: ${filePath}\n${content}`);
+  }
+  return parts.join('\n\n---\n\n');
+}
+
+function truncateToTokens(content: string, maxTokens: number, engine: ReviewEngine): string {
+  if (engine.estimateTokens(content) <= maxTokens) return content;
+  let lo = 0;
+  let hi = content.length;
+  while (hi - lo > 128) {
+    const mid = (lo + hi) >> 1;
+    if (engine.estimateTokens(content.slice(0, mid)) <= maxTokens) lo = mid;
+    else hi = mid;
+  }
+  return content.slice(0, lo) + '\n// [truncated]';
+}

package/src/core/config/loader.ts

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs/promises';
+import * as yaml from 'js-yaml';
+import Ajv from 'ajv';
+import { AutopilotError } from '../errors.ts';
+import type { AutopilotConfig } from './types.ts';
+import { AUTOPILOT_CONFIG_SCHEMA } from './schema.ts';
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+const validate = ajv.compile(AUTOPILOT_CONFIG_SCHEMA);
+
+export async function loadConfig(path: string): Promise<AutopilotConfig> {
+  let content: string;
+  try {
+    content = await fs.readFile(path, 'utf8');
+  } catch (err) {
+    throw new AutopilotError(`Config file not found: ${path}`, {
+      code: 'user_input',
+      details: { path, cause: err instanceof Error ? err.message : String(err) },
+    });
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = yaml.load(content);
+  } catch (err) {
+    throw new AutopilotError(`Invalid YAML in ${path}`, {
+      code: 'invalid_config',
+      details: { path, cause: err instanceof Error ? err.message : String(err) },
+    });
+  }
+
+  if (!validate(parsed)) {
+    const errors = (validate.errors ?? []).map(e => `${e.instancePath || '<root>'}: ${e.message}`);
+    throw new AutopilotError('Config schema validation failed', {
+      code: 'invalid_config',
+      details: { path, errors },
+    });
+  }
+
+  return parsed as AutopilotConfig;
+}

package/src/core/config/preset-resolver.ts

@@ -0,0 +1,46 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { loadConfig } from './loader.ts';
+import { AutopilotError } from '../errors.ts';
+import type { AutopilotConfig } from './types.ts';
+
+const PRESET_ROOT = path.resolve(process.cwd(), 'presets');
+
+export interface ResolvedPreset {
+  name: string;
+  config: AutopilotConfig;
+  stack: string;
+}
+
+export async function resolvePreset(name: string): Promise<ResolvedPreset> {
+  const presetDir = path.join(PRESET_ROOT, name);
+  try {
+    await fs.stat(presetDir);
+  } catch {
+    throw new AutopilotError(`Preset not found: ${name}`, {
+      code: 'invalid_config',
+      details: { name, presetDir },
+    });
+  }
+
+  const config = await loadConfig(path.join(presetDir, 'autopilot.config.yaml'));
+  let stack = '';
+  try {
+    stack = await fs.readFile(path.join(presetDir, 'stack.md'), 'utf8');
+  } catch {
+    stack = config.stack ?? '';
+  }
+  return { name, config, stack };
+}
+
+export function mergeConfigs(preset: AutopilotConfig, user: AutopilotConfig): AutopilotConfig {
+  return {
+    ...preset,
+    ...user,
+    // Arrays are concatenated (preset values first) so user additions don't discard preset invariants
+    protectedPaths: [...(preset.protectedPaths ?? []), ...(user.protectedPaths ?? [])],
+    staticRules: [...(preset.staticRules ?? []), ...(user.staticRules ?? [])],
+    thresholds: { ...preset.thresholds, ...user.thresholds },
+    chunking: { ...preset.chunking, ...user.chunking },
+  };
+}

package/src/core/config/schema.ts

@@ -0,0 +1,63 @@
+export const AUTOPILOT_CONFIG_SCHEMA = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  type: 'object',
+  required: ['configVersion'],
+  additionalProperties: false,
+  properties: {
+    configVersion: { const: 1 },
+    preset: { type: 'string' },
+    reviewEngine: { $ref: '#/definitions/adapterRef' },
+    vcsHost: { $ref: '#/definitions/adapterRef' },
+    migrationRunner: { $ref: '#/definitions/adapterRef' },
+    reviewBot: { $ref: '#/definitions/adapterRef' },
+    adapterAllowlist: { type: 'array', items: { type: 'string' } },
+    protectedPaths: { type: 'array', items: { type: 'string' } },
+    staticRules: {
+      type: 'array',
+      items: {
+        oneOf: [
+          { type: 'string' },
+          { type: 'object', required: ['adapter'], properties: { adapter: { type: 'string' }, options: { type: 'object' } } },
+        ],
+      },
+    },
+    staticRulesParallel: { type: 'boolean' },
+    stack: { type: 'string' },
+    testCommand: { type: ['string', 'null'] },
+    thresholds: {
+      type: 'object',
+      properties: {
+        bugbotAutoFix: { type: 'number' },
+        bugbotProposePatch: { type: 'number' },
+        maxValidateRetries: { type: 'number' },
+        maxCodexRetries: { type: 'number' },
+        maxBugbotRounds: { type: 'number' },
+      },
+      additionalProperties: false,
+    },
+    reviewStrategy: { enum: ['auto', 'single-pass', 'file-level'] },
+    chunking: {
+      type: 'object',
+      properties: {
+        smallTierMaxTokens: { type: 'number' },
+        partialReviewTokens: { type: 'number' },
+        perFileMaxTokens: { type: 'number' },
+        parallelism: { type: 'number' },
+        rateLimitBackoff: { enum: ['exp', 'linear', 'none'] },
+      },
+      additionalProperties: false,
+    },
+    cost: { type: 'object' },
+    cache: { type: 'object' },
+    persistence: { type: 'object' },
+    concurrency: { type: 'object' },
+  },
+  definitions: {
+    adapterRef: {
+      oneOf: [
+        { type: 'string' },
+        { type: 'object', required: ['adapter'], properties: { adapter: { type: 'string' }, options: { type: 'object' } } },
+      ],
+    },
+  },
+} as const;

package/src/core/config/types.ts

@@ -0,0 +1,42 @@
+export interface AdapterReference {
+  adapter: string;
+  options?: Record<string, unknown>;
+}
+
+export type AdapterRef = string | AdapterReference;
+
+export type StaticRuleReference = string | { adapter: string; options?: Record<string, unknown> };
+
+export interface AutopilotConfig {
+  configVersion: 1;
+  preset?: string;
+  reviewEngine?: AdapterRef;
+  vcsHost?: AdapterRef;
+  migrationRunner?: AdapterRef;
+  reviewBot?: AdapterRef;
+  adapterAllowlist?: string[];
+  protectedPaths?: string[];
+  staticRules?: StaticRuleReference[];
+  staticRulesParallel?: boolean;
+  stack?: string;
+  testCommand?: string | null;
+  thresholds?: {
+    bugbotAutoFix?: number;
+    bugbotProposePatch?: number;
+    maxValidateRetries?: number;
+    maxCodexRetries?: number;
+    maxBugbotRounds?: number;
+  };
+  reviewStrategy?: 'auto' | 'single-pass' | 'file-level';
+  chunking?: {
+    smallTierMaxTokens?: number;
+    partialReviewTokens?: number;
+    perFileMaxTokens?: number;
+    parallelism?: number;
+    rateLimitBackoff?: 'exp' | 'linear' | 'none';
+  };
+  cost?: Record<string, unknown>;
+  cache?: Record<string, unknown>;
+  persistence?: Record<string, unknown>;
+  concurrency?: Record<string, unknown>;
+}

package/src/core/errors.ts

@@ -0,0 +1,37 @@
+// src/core/errors.ts
+
+export type ErrorCode =
+  | 'auth' | 'rate_limit' | 'transient_network' | 'invalid_config'
+  | 'adapter_bug' | 'user_input' | 'budget_exceeded' | 'concurrency_lock' | 'superseded';
+
+export interface AutopilotErrorOptions {
+  code: ErrorCode;
+  retryable?: boolean;
+  provider?: string;
+  step?: string;
+  details?: Record<string, unknown>;
+}
+
+const DEFAULT_RETRYABLE: Record<ErrorCode, boolean> = {
+  auth: false, rate_limit: true, transient_network: true, invalid_config: false,
+  adapter_bug: false, user_input: false, budget_exceeded: false,
+  concurrency_lock: false, superseded: false,
+};
+
+export class AutopilotError extends Error {
+  code: ErrorCode;
+  retryable: boolean;
+  provider?: string;
+  step?: string;
+  details: Record<string, unknown>;
+
+  constructor(message: string, options: AutopilotErrorOptions) {
+    super(message);
+    this.name = 'AutopilotError';
+    this.code = options.code;
+    this.retryable = options.retryable ?? DEFAULT_RETRYABLE[options.code];
+    this.provider = options.provider;
+    this.step = options.step;
+    this.details = options.details ?? {};
+  }
+}

package/src/core/findings/dedup.ts

@@ -0,0 +1,14 @@
+import type { Finding } from './types.ts';
+
+export function findingContentKey(f: Finding): string {
+  return `${f.file}|${f.line ?? ''}|${f.severity}|${f.message.slice(0, 40)}`;
+}
+
+export function dedupFindings(findings: Finding[]): Finding[] {
+  const seen = new Map<string, Finding>();
+  for (const f of findings) {
+    const key = findingContentKey(f);
+    if (!seen.has(key)) seen.set(key, f);
+  }
+  return Array.from(seen.values());
+}

package/src/core/findings/types.ts

@@ -0,0 +1,39 @@
+// src/core/findings/types.ts
+
+export type FindingSource = 'static-rules' | 'review-engine' | 'pipeline' | `review-bot:${string}`;
+export type Severity = 'critical' | 'warning' | 'note';
+
+export interface Finding {
+  id: string;
+  source: FindingSource;
+  severity: Severity;
+  category: string;
+  file: string;
+  line?: number;
+  message: string;
+  suggestion?: string;
+  protectedPath: boolean;
+  createdAt: string;
+}
+
+export type TriageVerdict = 'real_bug' | 'false_positive' | 'low_value';
+export type TriageAction = 'auto_fix' | 'propose_patch' | 'ask_question' | 'dismiss' | 'needs_human';
+
+export interface TriageRecord {
+  findingId: string;
+  verdict: TriageVerdict;
+  confidence: number;
+  reason: string;
+  action: TriageAction;
+  recordedAt: string;
+}
+
+export type FixStatus = 'fixed' | 'reverted' | 'human_required' | 'skipped';
+
+export interface FixAttempt {
+  findingId: string;
+  attemptedAt: string;
+  status: FixStatus;
+  commitSha?: string;
+  notes?: string;
+}

package/src/core/git/touched-files.ts

@@ -0,0 +1,51 @@
+import { runSafe } from '../shell.ts';
+
+export interface TouchedFilesOptions {
+  cwd?: string;
+  base?: string; // e.g. 'HEAD~1', 'main', a SHA — defaults to HEAD~1
+}
+
+/**
+ * Returns the list of files changed relative to `base` (default HEAD~1).
+ * Falls back to `git status --short` unstaged/staged files if the diff fails
+ * (e.g. first commit, no parent).
+ */
+export function resolveGitTouchedFiles(options: TouchedFilesOptions = {}): string[] {
+  const cwd = options.cwd ?? process.cwd();
+  const base = options.base ?? 'HEAD~1';
+
+  // Primary: diff against base
+  const diffOut = runSafe('git', ['diff', '--name-only', base, 'HEAD'], { cwd });
+  if (diffOut !== null && diffOut.trim().length > 0) {
+    return parseFileList(diffOut);
+  }
+
+  // Fallback: staged + unstaged working tree changes
+  const statusOut = runSafe('git', ['status', '--short'], { cwd });
+  if (statusOut !== null && statusOut.trim().length > 0) {
+    return parseStatusOutput(statusOut);
+  }
+
+  return [];
+}
+
+function parseFileList(output: string): string[] {
+  return [...new Set(output.split('\n').map(l => l.trim()).filter(Boolean))];
+}
+
+function parseStatusOutput(output: string): string[] {
+  const files = new Set<string>();
+  for (const line of output.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    // format: XY filename  (or XY old -> new for renames)
+    const parts = trimmed.replace(/^\S+\s+/, '');
+    const renamed = parts.match(/^(.+)\s+->\s+(.+)$/);
+    if (renamed) {
+      files.add(renamed[2]!.trim());
+    } else {
+      files.add(parts.trim());
+    }
+  }
+  return [...files];
+}

package/src/core/index.ts

@@ -0,0 +1 @@
+export {};

package/src/core/logging/ndjson-writer.ts

@@ -0,0 +1,37 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { applyRedaction, DEFAULT_REDACTION_PATTERNS } from './redaction.ts';
+
+export interface NdjsonLoggerOptions {
+  runId: string;
+  logsDir?: string;
+  redactionPatterns?: readonly string[];
+}
+
+export class NdjsonLogger {
+  private readonly runId: string;
+  private readonly filePath: string;
+  private readonly stream: fs.WriteStream;
+  private readonly redactionPatterns: readonly string[];
+
+  constructor(options: NdjsonLoggerOptions) {
+    this.runId = options.runId;
+    this.redactionPatterns = options.redactionPatterns ?? DEFAULT_REDACTION_PATTERNS;
+    const logsDir = options.logsDir ?? path.join('.claude', 'logs');
+    fs.mkdirSync(logsDir, { recursive: true });
+    this.filePath = path.join(logsDir, `${this.runId}.ndjson`);
+    this.stream = fs.createWriteStream(this.filePath, { flags: 'a' });
+  }
+
+  log(event: string, fields: Record<string, unknown> = {}): void {
+    const entry = { ts: new Date().toISOString(), runId: this.runId, event, ...fields };
+    const serialized = applyRedaction(JSON.stringify(entry), this.redactionPatterns);
+    this.stream.write(serialized + '\n');
+  }
+
+  close(): Promise<void> {
+    return new Promise(resolve => this.stream.end(() => resolve()));
+  }
+
+  getFilePath(): string { return this.filePath; }
+}

package/src/core/logging/redaction.ts

@@ -0,0 +1,19 @@
+export const DEFAULT_REDACTION_PATTERNS: readonly string[] = Object.freeze([
+  '\\bsk-[a-zA-Z0-9_-]{20,}',
+  '\\beyJ[a-zA-Z0-9_-]{30,}',
+  '\\bghp_[a-zA-Z0-9]{30,}',
+  '\\bxoxb-[a-zA-Z0-9-]{20,}',
+  '\\bAKIA[A-Z0-9]{16}\\b',
+]);
+
+export function applyRedaction(text: string, patterns: readonly string[]): string {
+  let result = text;
+  for (const pattern of patterns) {
+    result = result.replace(new RegExp(pattern, 'g'), '[REDACTED]');
+  }
+  return result;
+}
+
+export function containsSecret(text: string, patterns: readonly string[]): boolean {
+  return patterns.some(p => new RegExp(p).test(text));
+}

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

@@ -0,0 +1,80 @@
+import type { Finding, FixAttempt, FixStatus } from '../findings/types.ts';
+import { dedupFindings, findingContentKey } from '../findings/dedup.ts';
+
+export interface StaticRule {
+  name: string;
+  severity: 'critical' | 'warning' | 'note';
+  check(touchedFiles: string[]): Promise<Finding[]>;
+  autofix?(finding: Finding): Promise<FixStatus>;
+}
+
+export interface StaticRulesPhaseInput {
+  touchedFiles: string[];
+  rules: StaticRule[];
+}
+
+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));
+
+  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))
+    : 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[]): Promise<Finding[]> {
+  const all: Finding[] = [];
+  for (const rule of rules) all.push(...(await rule.check(files)));
+  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

@@ -0,0 +1,51 @@
+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 };
+}