@delegance/claude-autopilot 5.0.1 → 5.0.3

package/src/core/config/types.ts

@@ -1,98 +0,0 @@
-import type { SchemaAlignmentConfig } from '../schema-alignment/types.ts';
-
-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 GuardrailConfig {
-  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;
-  };
-  ignore?: Array<string | { rule?: string; path: string }>;
-  reviewStrategy?: 'auto' | 'single-pass' | 'file-level' | 'diff' | 'auto-diff';
-  chunking?: {
-    smallTierMaxTokens?: number;
-    partialReviewTokens?: number;
-    perFileMaxTokens?: number;
-    parallelism?: number;
-    rateLimitBackoff?: 'exp' | 'linear' | 'none';
-  };
-  policy?: {
-    /** Severity threshold for exit code 1. Default: 'critical'. Use 'none' to always pass. */
-    failOn?: 'critical' | 'warning' | 'note' | 'none';
-    /** Only report findings not present in the committed baseline. Default: false. */
-    newOnly?: boolean;
-    /** Path to baseline file relative to cwd. Default: .guardrail-baseline.json */
-    baselinePath?: string;
-  };
-  pipeline?: {
-    /**
-     * When true, run the LLM review phase even if the static-rules phase reports `fail`
-     * (i.e. finds a critical). Default: true. Set to false to skip only the review
-     * phase on static-fail — the tests phase still runs regardless.
-     *
-     * Users that explicitly configure a review engine typically expect it to run — the
-     * bugs the LLM is best at (IDOR, TOCTOU, CORS, off-by-one, rate limits) often sit
-     * in the same commit as something a static rule already flagged. This flag only
-     * gates the review phase, mirroring `runReviewOnTestFail`.
-     */
-    runReviewOnStaticFail?: boolean;
-    /**
-     * When true, run the LLM review phase even if the tests phase reports `fail`.
-     * Default: false — failing tests usually indicate broken code, not code to review.
-     * This flag only gates the review phase; the tests phase itself always runs.
-     */
-    runReviewOnTestFail?: boolean;
-  };
-  cost?: {
-    /** Abort review phase if estimated spend exceeds this amount (USD). */
-    maxPerRun?: number;
-    /** Print token estimate before starting LLM review. Default: false. */
-    estimateBeforeRun?: boolean;
-    /** Per-model token price overrides (input/output per 1M tokens). */
-    pricing?: Record<string, { inputPer1M: number; outputPer1M: number }>;
-  };
-  brand?: {
-    /** Path to tailwind.config.{ts,js} — auto-extracts theme.colors as canonical palette */
-    colorsFrom?: string;
-    /** Explicit canonical color values (hex/rgb/hsl). Merged with colorsFrom. */
-    colors?: string[];
-    /** Canonical font family names */
-    fonts?: string[];
-    /** Path to design system component library (informational, for future LLM review) */
-    componentLibrary?: string | { tokens?: string; guide?: string };
-  };
-  'schema-alignment'?: SchemaAlignmentConfig;
-  cache?: Record<string, unknown>;
-  persistence?: Record<string, unknown>;
-  concurrency?: Record<string, unknown>;
-  council?: {
-    models: Array<{ adapter: string; model: string; label: string }>;
-    synthesizer: { adapter: string; model: string; label: string };
-    timeout_ms?: number;
-    min_successful_responses?: number;
-    parallel_input_max_tokens?: number;
-    synthesis_input_max_tokens?: number;
-  };
-}

package/src/core/council/config.ts

@@ -1,71 +0,0 @@
-// src/core/council/config.ts
-import { GuardrailError } from '../errors.ts';
-import type { CouncilConfig, CouncilModelEntry } from './types.ts';
-
-const SUPPORTED_ADAPTERS = new Set(['claude', 'openai']);
-
-export function parseCouncilConfig(raw: Record<string, unknown>): CouncilConfig {
-  const models = raw['models'] as Array<Record<string, string>> | undefined;
-  const synthRaw = raw['synthesizer'] as Record<string, string> | undefined;
-  const timeoutMs = (raw['timeout_ms'] as number | undefined) ?? 30000;
-  const minSuccessful = (raw['min_successful_responses'] as number | undefined) ?? 1;
-  const parallelInputMaxTokens = (raw['parallel_input_max_tokens'] as number | undefined) ?? 8000;
-  const synthesisInputMaxTokens = (raw['synthesis_input_max_tokens'] as number | undefined) ?? 12000;
-
-  if (!Array.isArray(models) || models.length < 2) {
-    throw new GuardrailError('council.models must have at least 2 entries', { code: 'invalid_config' });
-  }
-
-  if (!synthRaw?.['adapter'] || !synthRaw['model'] || !synthRaw['label']) {
-    throw new GuardrailError('council.synthesizer requires adapter, model, and label', { code: 'invalid_config' });
-  }
-
-  if (timeoutMs < 5000) {
-    throw new GuardrailError(`council.timeout_ms must be >= 5000, got ${timeoutMs}`, { code: 'invalid_config' });
-  }
-
-  if (minSuccessful < 1 || minSuccessful > models.length) {
-    throw new GuardrailError(
-      `council.min_successful_responses must be 1–${models.length}, got ${minSuccessful}`,
-      { code: 'invalid_config' },
-    );
-  }
-
-  for (const entry of [...models, synthRaw]) {
-    if (!SUPPORTED_ADAPTERS.has(entry['adapter']!)) {
-      throw new GuardrailError(
-        `council: unknown adapter "${entry['adapter']}" — supported: ${[...SUPPORTED_ADAPTERS].join(', ')}`,
-        { code: 'invalid_config' },
-      );
-    }
-  }
-
-  const seen = new Set<string>();
-  for (const m of models) {
-    if (seen.has(m['label']!)) {
-      throw new GuardrailError(`council.models: duplicate label "${m['label']}"`, { code: 'invalid_config' });
-    }
-    seen.add(m['label']!);
-  }
-
-  const parsedModels: CouncilModelEntry[] = models.map(m => ({
-    adapter: m['adapter'] as 'claude' | 'openai',
-    model: m['model']!,
-    label: m['label']!,
-  }));
-
-  const synthesizer: CouncilModelEntry = {
-    adapter: synthRaw['adapter'] as 'claude' | 'openai',
-    model: synthRaw['model']!,
-    label: synthRaw['label']!,
-  };
-
-  return {
-    models: parsedModels,
-    synthesizer,
-    timeoutMs,
-    minSuccessfulResponses: minSuccessful,
-    parallelInputMaxTokens,
-    synthesisInputMaxTokens,
-  };
-}

package/src/core/council/context.ts

@@ -1,17 +0,0 @@
-const CHARS_PER_TOKEN = 4;
-
-export function windowContext(text: string, maxTokens: number): string {
-  const estimated = Math.ceil(text.length / CHARS_PER_TOKEN);
-  if (estimated <= maxTokens) return text;
-
-  const maxChars = maxTokens * CHARS_PER_TOKEN;
-  // Reserve budget for the marker so the final output stays within maxTokens.
-  // Use a conservative upper bound of the formatted marker (the digit count of
-  // charsDropped is computed from text length to avoid circular dependency).
-  const markerOverhead = `<!-- [council: truncated ${text.length} chars] -->\n`.length;
-  const effectiveMaxChars = Math.max(0, maxChars - markerOverhead);
-  const charsDropped = text.length - effectiveMaxChars;
-  const marker = `<!-- [council: truncated ${charsDropped} chars] -->\n`;
-  process.stderr.write(`[council] context truncated: dropped ${charsDropped} chars to fit ${maxTokens} token budget\n`);
-  return marker + text.slice(charsDropped);
-}

package/src/core/council/runner.ts

@@ -1,83 +0,0 @@
-import * as crypto from 'node:crypto';
-import { windowContext } from './context.ts';
-import type { CouncilConfig, CouncilResult, ModelResponse } from './types.ts';
-import type { CouncilAdapter } from '../../adapters/council/types.ts';
-
-async function consultWithTimeout(
-  adapter: CouncilAdapter,
-  prompt: string,
-  context: string,
-  timeoutMs: number,
-): Promise<ModelResponse> {
-  const start = Date.now();
-  let timer: NodeJS.Timeout | undefined;
-  try {
-    const text = await Promise.race([
-      adapter.consult(prompt, context),
-      new Promise<never>((_, reject) => {
-        timer = setTimeout(() => reject(new Error('timeout')), timeoutMs);
-      }),
-    ]);
-    return { label: adapter.label, status: 'ok', text, latencyMs: Date.now() - start };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return message === 'timeout'
-      ? { label: adapter.label, status: 'timeout', error: 'timed out', latencyMs: Date.now() - start }
-      : { label: adapter.label, status: 'error', error: message, latencyMs: Date.now() - start };
-  } finally {
-    // Always clear the timer to avoid keeping the event loop alive after the
-    // adapter resolves/rejects. Long-running hosts (MCP server) would accumulate
-    // dangling timers for the full timeoutMs otherwise.
-    if (timer) clearTimeout(timer);
-  }
-}
-
-export async function runCouncil(
-  config: CouncilConfig,
-  adapters: CouncilAdapter[],
-  synthesizer: CouncilAdapter,
-  prompt: string,
-  contextDoc: string,
-): Promise<CouncilResult> {
-  const run_id = crypto.randomUUID();
-  const context = windowContext(contextDoc, config.parallelInputMaxTokens);
-
-  const responses = await Promise.all(
-    adapters.map(a => consultWithTimeout(a, prompt, context, config.timeoutMs))
-  );
-
-  const successful = responses.filter(r => r.status === 'ok');
-
-  if (successful.length < config.minSuccessfulResponses) {
-    return { schema_version: 1, run_id, status: 'failed', prompt, responses };
-  }
-
-  const responseSections = successful
-    .map(r => `### ${r.label}\n${r.text}`)
-    .join('\n\n');
-
-  const synthesisDoc = `${contextDoc}\n\n---\n\n${responseSections}`;
-  const synthesisCtx = windowContext(synthesisDoc, config.synthesisInputMaxTokens);
-  const synthesisPrompt = [
-    `You have received responses from multiple technical advisors on the following question:\n\n## Original Question\n\n${prompt}`,
-    `## Advisor Responses\n\n${responseSections}`,
-    'Based on these responses, provide a synthesis: areas of agreement, key disagreements, and your final recommendation.',
-  ].join('\n\n');
-
-  // Synthesizer shares the same per-call timeout as model calls so a hung
-  // synthesizer API doesn't block the whole command indefinitely.
-  const synthResponse = await consultWithTimeout(
-    synthesizer,
-    synthesisPrompt,
-    synthesisCtx,
-    config.timeoutMs,
-  );
-  // status:'ok' means the synthesizer call itself completed without error.
-  // Empty text is valid (e.g. the --no-synthesize stub that intentionally
-  // returns ''); only treat actual failures/timeouts as partial.
-  if (synthResponse.status === 'ok') {
-    const synthesis = { label: synthesizer.label, text: synthResponse.text ?? '', latencyMs: synthResponse.latencyMs };
-    return { schema_version: 1, run_id, status: 'success', prompt, responses, synthesis };
-  }
-  return { schema_version: 1, run_id, status: 'partial', prompt, responses };
-}

package/src/core/council/types.ts

@@ -1,45 +0,0 @@
-// adapter is a closed union — extending to a new provider requires an intentional
-// code change in config.ts and cli/council.ts
-export interface CouncilModelEntry {
-  adapter: 'claude' | 'openai';
-  model: string;
-  label: string;
-}
-
-export interface CouncilConfig {
-  models: CouncilModelEntry[];
-  synthesizer: CouncilModelEntry;
-  timeoutMs: number;
-  minSuccessfulResponses: number;
-  parallelInputMaxTokens: number;
-  synthesisInputMaxTokens: number;
-}
-
-export type ModelResponseStatus = 'ok' | 'timeout' | 'error';
-
-export interface ModelResponse {
-  label: string;
-  status: ModelResponseStatus;
-  text?: string;
-  error?: string;
-  latencyMs: number;
-}
-
-export interface SynthesisResponse {
-  label: string;
-  text: string;
-  latencyMs: number;
-}
-
-export type CouncilStatus = 'success' | 'partial' | 'failed';
-
-export interface CouncilResult {
-  // snake_case: wire-format field, consistent with MCP handler schema_version convention
-  schema_version: 1;
-  // snake_case: wire-format field
-  run_id: string;
-  status: CouncilStatus;
-  prompt: string;
-  responses: ModelResponse[];
-  synthesis?: SynthesisResponse;
-}

package/src/core/detect/git-context.ts

@@ -1,27 +0,0 @@
-import { runSafe } from '../shell.ts';
-
-export interface GitContext {
-  branch: string | null;
-  commitMessage: string | null;
-  /** Short summary suitable for injecting into a review prompt */
-  summary: string | null;
-}
-
-/**
- * Reads branch name and last commit message from git. Returns nulls gracefully
- * if git is unavailable or the repo has no commits.
- */
-export function detectGitContext(cwd: string): GitContext {
-  const branch = runSafe('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD'])?.trim() ?? null;
-  const commitMessage = runSafe('git', ['-C', cwd, 'log', '-1', '--format=%s'])?.trim() ?? null;
-
-  let summary: string | null = null;
-  if (branch || commitMessage) {
-    const parts: string[] = [];
-    if (branch && branch !== 'HEAD') parts.push(`branch: ${branch}`);
-    if (commitMessage) parts.push(`last commit: ${commitMessage}`);
-    summary = parts.join(' | ');
-  }
-
-  return { branch, commitMessage, summary };
-}

package/src/core/detect/llm-key.ts

@@ -1,89 +0,0 @@
-/**
- * Shared LLM API key detection. Used by setup, doctor/preflight, scan, and run so
- * every surface agrees on which env vars count as "have a key."
- *
- * Before this unified helper, doctor only checked ANTHROPIC_API_KEY + OPENAI_API_KEY
- * while setup/scan/run checked all 5 providers — producing contradictory messages
- * ("LLM API key: detected" from setup, "No LLM API key" from doctor moments later).
- */
-
-import * as fs from 'node:fs';
-
-/** All env var names guardrail recognizes as LLM API keys, ordered by preference. */
-export const LLM_KEY_NAMES = [
-  'ANTHROPIC_API_KEY',
-  'OPENAI_API_KEY',
-  'GEMINI_API_KEY',
-  'GOOGLE_API_KEY',
-  'GROQ_API_KEY',
-] as const;
-
-export type LLMKeyName = typeof LLM_KEY_NAMES[number];
-
-export interface KeyDetectionOptions {
-  /** Additional key→value map to check alongside process.env (e.g. parsed .env.local). */
-  extraEnv?: Record<string, string | undefined>;
-}
-
-export interface KeyDetectionResult {
-  /** True if any recognized LLM key is set to a non-empty value. */
-  hasKey: boolean;
-  /** Preferred key that was detected, or null. Follows LLM_KEY_NAMES order. */
-  preferred: LLMKeyName | null;
-  /** All keys that were detected, in LLM_KEY_NAMES order. */
-  detected: LLMKeyName[];
-}
-
-function readEnvFileSync(filePath: string): Record<string, string> {
-  const vars: Record<string, string> = {};
-  try {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith('#')) continue;
-      const eq = trimmed.indexOf('=');
-      if (eq < 0) continue;
-      vars[trimmed.slice(0, eq).trim()] = trimmed.slice(eq + 1).trim().replace(/^['"]|['"]$/g, '');
-    }
-  } catch {
-    /* ignore */
-  }
-  return vars;
-}
-
-/** Load an env file into a plain object without mutating process.env. */
-export function loadEnvFile(filePath: string): Record<string, string> {
-  return readEnvFileSync(filePath);
-}
-
-/** Detect whether any recognized LLM API key is set. */
-export function detectLLMKey(options: KeyDetectionOptions = {}): KeyDetectionResult {
-  const extra = options.extraEnv ?? {};
-  const detected: LLMKeyName[] = [];
-  for (const name of LLM_KEY_NAMES) {
-    // Treat empty string as "not set" so an env file value can supply the key when
-    // the shell has `FOO=` exported. `??` would shadow the env file here because it
-    // only falls through on null/undefined — matching the old `!! || !!` semantics.
-    const fromProcess = process.env[name];
-    const value = (fromProcess && fromProcess.length > 0) ? fromProcess : extra[name];
-    if (value && value.length > 0) detected.push(name);
-  }
-  return {
-    hasKey: detected.length > 0,
-    preferred: detected[0] ?? null,
-    detected,
-  };
-}
-
-/**
- * Human-readable list of providers and signup URLs, used by every "no key" message.
- * Must cover every entry in LLM_KEY_NAMES so users see the same set of options across
- * preflight, setup, scan, and run.
- */
-export const LLM_KEY_HINTS: Array<{ name: LLMKeyName; url: string; note?: string }> = [
-  { name: 'ANTHROPIC_API_KEY', url: 'https://console.anthropic.com/' },
-  { name: 'OPENAI_API_KEY',    url: 'https://platform.openai.com/api-keys' },
-  { name: 'GEMINI_API_KEY',    url: 'https://aistudio.google.com/app/apikey' },
-  { name: 'GOOGLE_API_KEY',    url: 'https://aistudio.google.com/app/apikey', note: 'legacy alias for GEMINI_API_KEY' },
-  { name: 'GROQ_API_KEY',      url: 'https://console.groq.com/keys', note: 'fast free tier' },
-];

package/src/core/detect/protected-paths.ts

@@ -1,63 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-interface MigrationSignal {
-  glob: string;
-  check: (cwd: string) => boolean;
-}
-
-const MIGRATION_SIGNALS: MigrationSignal[] = [
-  { glob: 'data/deltas/**',           check: c => fs.existsSync(path.join(c, 'data', 'deltas')) },
-  { glob: 'migrations/**',            check: c => fs.existsSync(path.join(c, 'migrations')) },
-  { glob: 'db/migrate/**',            check: c => fs.existsSync(path.join(c, 'db', 'migrate')) },
-  { glob: 'database/migrations/**',   check: c => fs.existsSync(path.join(c, 'database', 'migrations')) },
-  { glob: 'prisma/migrations/**',     check: c => fs.existsSync(path.join(c, 'prisma', 'migrations')) },
-  { glob: 'alembic/versions/**',      check: c => fs.existsSync(path.join(c, 'alembic', 'versions')) },
-  { glob: 'flyway/**',                check: c => fs.existsSync(path.join(c, 'flyway')) },
-  // *.sql is handled below via readdirSync
-];
-
-const SCHEMA_FILES = [
-  'prisma/schema.prisma',
-  'schema.prisma',
-  'schema.sql',
-  'db/schema.rb',
-  'config/schema.xml',
-];
-
-const INFRA_SIGNALS: Array<{ glob: string; check: (cwd: string) => boolean }> = [
-  { glob: 'terraform/**',      check: c => fs.existsSync(path.join(c, 'terraform')) },
-  { glob: 'infra/**',          check: c => fs.existsSync(path.join(c, 'infra')) },
-  { glob: '.github/workflows/**', check: c => fs.existsSync(path.join(c, '.github', 'workflows')) },
-  { glob: 'k8s/**',            check: c => fs.existsSync(path.join(c, 'k8s')) },
-  { glob: 'helm/**',           check: c => fs.existsSync(path.join(c, 'helm')) },
-];
-
-/**
- * Scans the project for migration directories, schema files, and infra configs
- * and returns glob patterns suitable for `protectedPaths`.
- */
-export function detectProtectedPaths(cwd: string): string[] {
-  const found = new Set<string>();
-
-  for (const sig of MIGRATION_SIGNALS) {
-    if (sig.check(cwd)) found.add(sig.glob);
-  }
-
-  // Root-level .sql files
-  try {
-    if (fs.readdirSync(cwd).some(f => f.endsWith('.sql'))) found.add('*.sql');
-  } catch { /* ignore */ }
-
-  for (const rel of SCHEMA_FILES) {
-    if (fs.existsSync(path.join(cwd, rel))) {
-      found.add(rel.includes('/') ? rel.split('/')[0] + '/**' : rel);
-    }
-  }
-
-  for (const sig of INFRA_SIGNALS) {
-    if (sig.check(cwd)) found.add(sig.glob);
-  }
-
-  return Array.from(found).sort();
-}

package/src/core/detect/provider-usage.ts

@@ -1,74 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-export type Provider = 'anthropic' | 'gemini' | 'openai' | 'groq';
-
-const PROVIDER_PATTERNS: Record<Provider, RegExp> = {
-  anthropic: /ANTHROPIC_API_KEY|@anthropic-ai\/sdk|anthropic\.com|claude-[a-z0-9]/gi,
-  gemini:    /GEMINI_API_KEY|GOOGLE_API_KEY|@google\/generative-ai|generativelanguage\.googleapis/gi,
-  openai:    /OPENAI_API_KEY|openai\.com|gpt-[0-9]/gi,
-  groq:      /GROQ_API_KEY|api\.groq\.com/gi,
-};
-
-const SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.go', '.rb']);
-
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.nuxt', 'out',
-  'coverage', '__pycache__', '.venv', 'venv', 'target', '.gradle', '.cache', '.turbo']);
-
-function walkSync(dir: string, files: string[] = []): string[] {
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return files;
-  }
-  for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkSync(full, files);
-    } else if (entry.isFile() && SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-
-export interface ProviderCounts {
-  anthropic: number;
-  gemini: number;
-  openai: number;
-  groq: number;
-}
-
-/**
- * Scans source files under `cwd` and returns per-provider match counts.
- * Counts are capped at 1 per file to avoid skewing on generated lock files.
- */
-export function detectProviderUsage(cwd: string): ProviderCounts {
-  const counts: ProviderCounts = { anthropic: 0, gemini: 0, openai: 0, groq: 0 };
-  const files = walkSync(cwd);
-  for (const file of files) {
-    let content: string;
-    try {
-      content = fs.readFileSync(file, 'utf8');
-    } catch {
-      continue;
-    }
-    for (const [provider, pattern] of Object.entries(PROVIDER_PATTERNS) as [Provider, RegExp][]) {
-      pattern.lastIndex = 0;
-      if (pattern.test(content)) counts[provider]++;
-    }
-  }
-  return counts;
-}
-
-/**
- * Returns the provider with the highest usage count, or null if all zero.
- */
-export function dominantProvider(counts: ProviderCounts): Provider | null {
-  const entries = Object.entries(counts) as [Provider, number][];
-  const max = Math.max(...entries.map(([, v]) => v));
-  if (max === 0) return null;
-  return entries.find(([, v]) => v === max)![0];
-}