@delegance/claude-autopilot 5.0.1 → 5.0.2

package/src/adapters/loader.ts

@@ -1,108 +0,0 @@
-import * as path from 'node:path';
-import { GuardrailError } from '../core/errors.ts';
-import { checkApiVersionCompatibility, type AdapterBase } from './base.ts';
-import { resolveSiblingModule } from '../cli/_pkg-root.ts';
-
-export type IntegrationPoint = 'review-engine' | 'vcs-host' | 'migration-runner' | 'review-bot-parser';
-
-export interface LoadAdapterOptions {
-  point: IntegrationPoint;
-  ref: string;
-  options?: Record<string, unknown>;
-  /** Allow loading adapters from arbitrary local paths. Off by default for security. */
-  unsafeAllowLocalAdapters?: boolean;
-}
-
-const BUILTIN_PATHS: Record<IntegrationPoint, Record<string, string>> = {
-  'review-engine': {
-    codex: './review-engine/codex.ts',
-    claude: './review-engine/claude.ts',
-    gemini: './review-engine/gemini.ts',
-    'openai-compatible': './review-engine/openai-compatible.ts',
-    auto: './review-engine/auto.ts',
-  },
-  'vcs-host': { github: './vcs-host/github.ts' },
-  'migration-runner': { supabase: './migration-runner/supabase.ts' },
-  'review-bot-parser': { cursor: './review-bot-parser/cursor.ts' },
-};
-
-const REQUIRED_BY_POINT: Record<IntegrationPoint, string[]> = {
-  'review-engine': ['review', 'estimateTokens'],
-  'vcs-host': ['getPrDiff', 'getPrMetadata', 'postComment', 'getReviewComments', 'replyToComment', 'createPr', 'push'],
-  'migration-runner': ['discover', 'dryRun', 'apply', 'ledger', 'alreadyApplied'],
-  'review-bot-parser': ['detect', 'fetchFindings', 'detectDismissal'],
-};
-
-function isPathRef(ref: string): boolean {
-  return ref.startsWith('./') || ref.startsWith('/') || ref.startsWith('../') || ref.endsWith('.ts') || ref.endsWith('.js');
-}
-
-export async function loadAdapter<T extends AdapterBase>(options: LoadAdapterOptions): Promise<T> {
-  const { point, ref } = options;
-  let modulePath: string;
-
-  if (isPathRef(ref)) {
-    if (!options.unsafeAllowLocalAdapters) {
-      throw new GuardrailError(
-        `Path-based adapter refs require unsafeAllowLocalAdapters:true — set this only for trusted local adapters`,
-        { code: 'invalid_config', details: { point, ref } }
-      );
-    }
-    modulePath = path.resolve(ref);
-  } else {
-    const builtin = BUILTIN_PATHS[point]?.[ref];
-    if (!builtin) {
-      throw new GuardrailError(`Unknown built-in ${point} adapter: "${ref}"`, {
-        code: 'invalid_config',
-        details: { point, ref, available: Object.keys(BUILTIN_PATHS[point] ?? {}) },
-      });
-    }
-    modulePath = resolveSiblingModule(builtin, import.meta.url);
-  }
-
-  let mod: { default?: T } | T;
-  try {
-    mod = (await import(modulePath)) as { default?: T } | T;
-  } catch (err) {
-    throw new GuardrailError(`Failed to import adapter from ${modulePath}`, {
-      code: 'invalid_config',
-      details: { point, ref, modulePath, cause: err instanceof Error ? err.message : String(err) },
-    });
-  }
-
-  const adapter = ('default' in mod ? mod.default : mod) as T;
-  if (!adapter || typeof adapter !== 'object') {
-    throw new GuardrailError(`Adapter module did not export a valid adapter object`, {
-      code: 'invalid_config',
-      details: { point, ref, modulePath },
-    });
-  }
-
-  validateShape(adapter, point, modulePath);
-
-  if (!checkApiVersionCompatibility(adapter.apiVersion)) {
-    throw new GuardrailError(`Adapter apiVersion ${adapter.apiVersion} incompatible with core`, {
-      code: 'invalid_config',
-      details: { point, ref, adapterApiVersion: adapter.apiVersion },
-    });
-  }
-
-  return adapter;
-}
-
-function validateShape(adapter: AdapterBase, point: IntegrationPoint, modulePath: string): void {
-  const missing: string[] = [];
-  const required = ['getCapabilities', ...REQUIRED_BY_POINT[point]];
-  for (const method of required) {
-    if (typeof (adapter as unknown as Record<string, unknown>)[method] !== 'function') missing.push(method);
-  }
-  if (typeof adapter.name !== 'string' || typeof adapter.apiVersion !== 'string') {
-    missing.push('name/apiVersion');
-  }
-  if (missing.length > 0) {
-    throw new GuardrailError(
-      `Adapter at ${modulePath} missing required methods: ${missing.join(', ')}`,
-      { code: 'invalid_config', details: { point, modulePath, missing } }
-    );
-  }
-}

package/src/adapters/migration-runner/supabase.ts

@@ -1,56 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { runSafe } from '../../core/shell.ts';
-import type { Capabilities } from '../base.ts';
-import type { MigrationRunner, Migration, MigrationEnv, DryRunResult, ApplyResult, LedgerEntry } from './types.ts';
-
-export const supabaseAdapter: MigrationRunner = {
-  name: 'supabase',
-  apiVersion: '1.0.0',
-
-  getCapabilities(): Capabilities {
-    return { structuredOutput: false, streaming: false, maxContextTokens: 0, inlineComments: false };
-  },
-
-  discover(touchedFiles: string[]): Migration[] {
-    const sqlFiles = touchedFiles.filter(f => f.match(/data\/deltas\/[^/]+\.sql$/));
-    return sqlFiles.map(p => ({
-      name: path.basename(p, '.sql'),
-      path: p,
-    }));
-  },
-
-  async dryRun(migration: Migration): Promise<DryRunResult> {
-    try {
-      const content = migration.content ?? fs.readFileSync(migration.path, 'utf8');
-      if (!content.trim()) return { ok: false, errors: ['Migration file is empty'] };
-      return { ok: true };
-    } catch (err) {
-      return { ok: false, errors: [err instanceof Error ? err.message : String(err)] };
-    }
-  },
-
-  async apply(migration: Migration, env: MigrationEnv): Promise<ApplyResult> {
-    const start = Date.now();
-    const envFlag = env === 'prod' ? '--prod' : env === 'qa' ? '--qa' : '';
-    const args = ['tsx', 'scripts/supabase/migrate.ts', migration.path];
-    if (envFlag) args.push(envFlag);
-    const result = runSafe('npx', args);
-    if (result === null) {
-      return { ok: false, errors: [`Migration apply failed for ${migration.name} on ${env}`] };
-    }
-    return { ok: true, durationMs: Date.now() - start };
-  },
-
-  async ledger(_env: MigrationEnv): Promise<LedgerEntry[]> {
-    // alpha.1: full ledger query lands in alpha.2
-    return [];
-  },
-
-  async alreadyApplied(migration: Migration, _env: MigrationEnv): Promise<boolean> {
-    const result = runSafe('npx', ['tsx', 'scripts/supabase/migrate.ts', migration.path, '--inspect']);
-    return result !== null && result.includes('already applied');
-  },
-};
-
-export default supabaseAdapter;

package/src/adapters/migration-runner/types.ts

@@ -1,36 +0,0 @@
-import type { AdapterBase } from '../base.ts';
-
-export type MigrationEnv = 'dev' | 'qa' | 'prod';
-
-export interface Migration {
-  name: string;
-  path: string;
-  content?: string;
-}
-
-export interface DryRunResult {
-  ok: boolean;
-  errors?: string[];
-  warnings?: string[];
-}
-
-export interface ApplyResult {
-  ok: boolean;
-  appliedSha?: string;
-  durationMs?: number;
-  errors?: string[];
-}
-
-export interface LedgerEntry {
-  name: string;
-  appliedAt: string;
-  sha?: string;
-}
-
-export interface MigrationRunner extends AdapterBase {
-  discover(touchedFiles: string[]): Migration[];
-  dryRun(migration: Migration): Promise<DryRunResult>;
-  apply(migration: Migration, env: MigrationEnv): Promise<ApplyResult>;
-  ledger(env: MigrationEnv): Promise<LedgerEntry[]>;
-  alreadyApplied(migration: Migration, env: MigrationEnv): Promise<boolean>;
-}

package/src/adapters/review-bot-parser/cursor.ts

@@ -1,13 +0,0 @@
-import { makeDeclarativeParser } from './declarative-base.ts';
-
-export const cursorAdapter = makeDeclarativeParser({
-  name: 'cursor',
-  author: 'cursor[bot]',
-  severityMap: {
-    critical: /\bhigh\b|\bcritical\b/i,
-    warning: /\bmedium\b|\bwarning\b/i,
-  },
-  dismissalKeywords: ['false positive', 'not an issue', 'intentional', 'wontfix'],
-});
-
-export default cursorAdapter;

package/src/adapters/review-bot-parser/declarative-base.ts

@@ -1,64 +0,0 @@
-import type { Finding } from '../../core/findings/types.ts';
-import type { GenericComment, VcsHost } from '../vcs-host/types.ts';
-import type { Capabilities } from '../base.ts';
-import type { ReviewBotParser } from './types.ts';
-
-export interface DeclarativeParserConfig {
-  name: string;
-  author: string | RegExp;
-  severityMap: { critical?: RegExp; warning?: RegExp; note?: RegExp };
-  dismissalKeywords: string[];
-}
-
-export function makeDeclarativeParser(config: DeclarativeParserConfig): ReviewBotParser {
-  const authorTest = typeof config.author === 'string'
-    ? (a: string) => a === config.author
-    : (a: string) => (config.author as RegExp).test(a);
-
-  return {
-    name: config.name,
-    apiVersion: '1.0.0',
-
-    getCapabilities(): Capabilities {
-      return { structuredOutput: false, streaming: false, maxContextTokens: 0, inlineComments: true };
-    },
-
-    detect(comment: GenericComment): boolean {
-      return authorTest(comment.author);
-    },
-
-    async fetchFindings(vcs: VcsHost, pr: number | string): Promise<Finding[]> {
-      const comments = await vcs.getReviewComments(pr);
-      const botComments = comments.filter(c => authorTest(c.author));
-      return botComments.map((c, idx) => {
-        const body = c.body ?? '';
-        const severity = matchSeverity(body, config.severityMap);
-        return {
-          id: `${config.name}-${idx}-${c.id}`,
-          source: `review-bot:${config.name}` as const,
-          severity,
-          category: `${config.name}-finding`,
-          file: c.path ?? '<unspecified>',
-          line: c.line,
-          message: body.split('\n')[0]?.trim() ?? body,
-          protectedPath: false,
-          createdAt: new Date().toISOString(),
-        };
-      });
-    },
-
-    detectDismissal(reply: string): boolean {
-      const lower = reply.toLowerCase();
-      return config.dismissalKeywords.some(kw => lower.includes(kw));
-    },
-  };
-}
-
-function matchSeverity(
-  body: string,
-  map: DeclarativeParserConfig['severityMap']
-): Finding['severity'] {
-  if (map.critical && map.critical.test(body)) return 'critical';
-  if (map.warning && map.warning.test(body)) return 'warning';
-  return 'note';
-}

package/src/adapters/review-bot-parser/types.ts

@@ -1,9 +0,0 @@
-import type { AdapterBase } from '../base.ts';
-import type { Finding } from '../../core/findings/types.ts';
-import type { GenericComment, VcsHost } from '../vcs-host/types.ts';
-
-export interface ReviewBotParser extends AdapterBase {
-  detect(comment: GenericComment): boolean;
-  fetchFindings(vcs: VcsHost, pr: number | string): Promise<Finding[]>;
-  detectDismissal(reply: string): boolean;
-}

package/src/adapters/review-engine/auto.ts

@@ -1,94 +0,0 @@
-import type { Capabilities } from '../base.ts';
-import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
-import { GuardrailError } from '../../core/errors.ts';
-import { detectProviderUsage, dominantProvider, type Provider } from '../../core/detect/provider-usage.ts';
-
-interface AvailableProvider {
-  provider: Provider;
-  load: () => Promise<ReviewEngine>;
-}
-
-function buildGroqAdapter(base: ReviewEngine): ReviewEngine {
-  return {
-    ...base,
-    name: 'auto',
-    review(input: ReviewInput) {
-      return base.review({
-        ...input,
-        context: {
-          ...input.context,
-          model: 'llama-3.3-70b-versatile',
-          baseUrl: 'https://api.groq.com/openai/v1',
-          apiKeyEnv: 'GROQ_API_KEY',
-        } as typeof input.context,
-      });
-    },
-  };
-}
-
-function getAvailableProviders(): AvailableProvider[] {
-  const available: AvailableProvider[] = [];
-  if (process.env.ANTHROPIC_API_KEY) {
-    available.push({ provider: 'anthropic', load: async () => (await import('./claude.ts')).claudeAdapter });
-  }
-  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
-    available.push({ provider: 'gemini', load: async () => (await import('./gemini.ts')).geminiAdapter });
-  }
-  if (process.env.OPENAI_API_KEY) {
-    available.push({ provider: 'openai', load: async () => (await import('./codex.ts')).codexAdapter });
-  }
-  if (process.env.GROQ_API_KEY) {
-    available.push({
-      provider: 'groq',
-      load: async () => buildGroqAdapter((await import('./openai-compatible.ts')).openaiCompatibleAdapter),
-    });
-  }
-  return available;
-}
-
-async function resolveAdapter(cwd: string): Promise<ReviewEngine> {
-  const available = getAvailableProviders();
-
-  if (available.length === 0) {
-    throw new GuardrailError(
-      'No LLM API key found. Set one of: ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, GROQ_API_KEY',
-      { code: 'auth', provider: 'auto' },
-    );
-  }
-
-  // Single provider — no need to scan
-  if (available.length === 1) return available[0]!.load();
-
-  // Multiple keys present — prefer the provider most referenced in source code
-  const counts = detectProviderUsage(cwd);
-  const dominant = dominantProvider(counts);
-  if (dominant) {
-    const match = available.find(p => p.provider === dominant);
-    if (match) return match.load();
-  }
-
-  // Fallback to first available (env-key priority order)
-  return available[0]!.load();
-}
-
-export const autoAdapter: ReviewEngine = {
-  name: 'auto',
-  apiVersion: '1.0.0',
-
-  getCapabilities(): Capabilities {
-    return { structuredOutput: false, streaming: false, maxContextTokens: 200000, inlineComments: false };
-  },
-
-  estimateTokens(content: string): number {
-    return Math.ceil(content.length / 3.5);
-  },
-
-  async review(input: ReviewInput): Promise<ReviewOutput> {
-    const cwd = (input.context as Record<string, unknown> | undefined)?.['cwd'] as string | undefined
-      ?? process.cwd();
-    const adapter = await resolveAdapter(cwd);
-    return adapter.review(input);
-  },
-};
-
-export default autoAdapter;

package/src/adapters/review-engine/claude.ts

@@ -1,100 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { GuardrailError } from '../../core/errors.ts';
-import type { Capabilities } from '../base.ts';
-import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
-import { parseReviewOutput } from './parse-output.ts';
-import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
-
-const DEFAULT_MODEL = 'claude-opus-4-7';
-const MAX_OUTPUT_TOKENS = 4096;
-
-// Cost per million tokens (USD) — opus-4-7 pricing
-const COST_PER_M_INPUT = 15.0;
-const COST_PER_M_OUTPUT = 75.0;
-
-const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
-
-The codebase context:
-{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
-
-Provide structured feedback in exactly this format:
-
-## Review Summary
-One paragraph overall assessment.
-
-## Findings
-
-For each finding, use this format:
-### [CRITICAL|WARNING|NOTE] <short title>
-<explanation>
-**Suggestion:** <actionable fix>
-
-Rules:
-- CRITICAL: Blocks merge (security issues, data loss risks, broken contracts)
-- WARNING: Should address before merging (logic errors, missing error handling, test gaps)
-- NOTE: Improvement suggestion (style, performance, clarity)
-- Maximum 10 findings, ranked by severity
-- Be specific and constructive
-- Reference the file and line when possible`;
-
-export const claudeAdapter: ReviewEngine = {
-  name: 'claude',
-  apiVersion: '1.0.0',
-
-  getCapabilities(): Capabilities {
-    return { structuredOutput: false, streaming: false, maxContextTokens: 200000, inlineComments: false };
-  },
-
-  estimateTokens(content: string): number {
-    return Math.ceil(content.length / 3.5);
-  },
-
-  async review(input: ReviewInput): Promise<ReviewOutput> {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-      throw new GuardrailError('ANTHROPIC_API_KEY not set', { code: 'auth', provider: 'claude' });
-    }
-
-    const model = (input.context as Record<string, unknown> | undefined)?.['model'] as string | undefined ?? DEFAULT_MODEL;
-    const systemPrompt = buildSystemPrompt(input, SYSTEM_PROMPT_TEMPLATE);
-
-    const client = new Anthropic({ apiKey });
-    let response: Anthropic.Message;
-    try {
-      response = await client.messages.create({
-        model,
-        max_tokens: MAX_OUTPUT_TOKENS,
-        system: systemPrompt,
-        messages: [{ role: 'user', content: `Please review the following:\n\n---\n\n${input.content}` }],
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const code = classifyError(message);
-      throw new GuardrailError(`Claude review call failed: ${message}`, {
-        code,
-        provider: 'claude',
-        retryable: code === 'rate_limit',
-      });
-    }
-
-    const rawOutput = response.content
-      .filter(b => b.type === 'text')
-      .map(b => (b as Anthropic.TextBlock).text)
-      .join('');
-
-    const costUSD = response.usage
-      ? (response.usage.input_tokens / 1_000_000) * COST_PER_M_INPUT +
-        (response.usage.output_tokens / 1_000_000) * COST_PER_M_OUTPUT
-      : undefined;
-
-    return {
-      findings: parseReviewOutput(rawOutput, 'claude'),
-      rawOutput,
-      usage: response.usage
-        ? { input: response.usage.input_tokens, output: response.usage.output_tokens, costUSD }
-        : undefined,
-    };
-  },
-};
-
-export default claudeAdapter;

package/src/adapters/review-engine/codex.ts

@@ -1,82 +0,0 @@
-import OpenAI from 'openai';
-import { parseReviewOutput } from './parse-output.ts';
-import { GuardrailError } from '../../core/errors.ts';
-import type { Capabilities } from '../base.ts';
-import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
-import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
-
-const DEFAULT_MODEL = process.env.CODEX_MODEL ?? 'gpt-5.3-codex';
-const MAX_OUTPUT_TOKENS = 4096;
-
-const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect providing feedback on designs, proposals, and ideas.
-
-The codebase context:
-{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
-
-Provide structured feedback in exactly this format:
-
-## Review Summary
-One paragraph overall assessment.
-
-## Findings
-
-For each finding, use this format:
-### [CRITICAL|WARNING|NOTE] <short title>
-<explanation>
-**Suggestion:** <actionable fix>
-
-Rules:
-- CRITICAL: Blocks implementation
-- WARNING: Should address before implementing
-- NOTE: Improvement suggestion
-- Maximum 10 findings, ranked by severity
-- Be specific and constructive`;
-
-export const codexAdapter: ReviewEngine = {
-  name: 'codex',
-  apiVersion: '1.0.0',
-
-  getCapabilities(): Capabilities {
-    return { structuredOutput: false, streaming: false, maxContextTokens: 128000, inlineComments: false };
-  },
-
-  estimateTokens(content: string): number {
-    return Math.ceil(content.length / 4);
-  },
-
-  async review(input: ReviewInput): Promise<ReviewOutput> {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new GuardrailError('OPENAI_API_KEY not set', { code: 'auth', provider: 'codex' });
-    }
-    const systemPrompt = buildSystemPrompt(input, SYSTEM_PROMPT_TEMPLATE);
-
-    const client = new OpenAI({ apiKey });
-    let response;
-    try {
-      response = await client.responses.create({
-        model: DEFAULT_MODEL,
-        instructions: systemPrompt,
-        input: `Please review the following:\n\n---\n\n${input.content}`,
-        max_output_tokens: MAX_OUTPUT_TOKENS,
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const code = classifyError(message);
-      throw new GuardrailError(`Codex review call failed: ${message}`, {
-        code,
-        provider: 'codex',
-        retryable: code === 'rate_limit',
-      });
-    }
-
-    const rawOutput = response.output_text ?? '';
-    return {
-      findings: parseReviewOutput(rawOutput, 'codex'),
-      rawOutput,
-      usage: response.usage ? { input: response.usage.input_tokens, output: response.usage.output_tokens } : undefined,
-    };
-  },
-};
-
-export default codexAdapter;

package/src/adapters/review-engine/gemini.ts

@@ -1,105 +0,0 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
-import { parseReviewOutput } from './parse-output.ts';
-import { GuardrailError } from '../../core/errors.ts';
-import type { Capabilities } from '../base.ts';
-import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
-import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
-
-const DEFAULT_MODEL = 'gemini-2.5-pro-preview-05-06';
-const MAX_OUTPUT_TOKENS = 4096;
-
-// Cost per million tokens (USD) — gemini-2.5-pro pricing (<200k context)
-const COST_PER_M_INPUT = 1.25;
-const COST_PER_M_OUTPUT = 10.0;
-
-const PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
-
-The codebase context:
-{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
-
-Please review the following:
-
----
-
-{CONTENT}
-
----
-
-Provide structured feedback in exactly this format:
-
-## Review Summary
-One paragraph overall assessment.
-
-## Findings
-
-For each finding, use this format:
-### [CRITICAL|WARNING|NOTE] <short title>
-<explanation>
-**Suggestion:** <actionable fix>
-
-Rules:
-- CRITICAL: Blocks merge (security issues, data loss risks, broken contracts)
-- WARNING: Should address before merging (logic errors, missing error handling, test gaps)
-- NOTE: Improvement suggestion (style, performance, clarity)
-- Maximum 10 findings, ranked by severity
-- Be specific and constructive
-- Reference the file and line when possible`;
-
-export const geminiAdapter: ReviewEngine = {
-  name: 'gemini',
-  apiVersion: '1.0.0',
-
-  getCapabilities(): Capabilities {
-    return { structuredOutput: false, streaming: false, maxContextTokens: 1000000, inlineComments: false };
-  },
-
-  estimateTokens(content: string): number {
-    return Math.ceil(content.length / 4);
-  },
-
-  async review(input: ReviewInput): Promise<ReviewOutput> {
-    const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
-    if (!apiKey) {
-      throw new GuardrailError('GEMINI_API_KEY (or GOOGLE_API_KEY) not set', { code: 'auth', provider: 'gemini' });
-    }
-
-    const model = (input.context as Record<string, unknown> | undefined)?.['model'] as string | undefined ?? DEFAULT_MODEL;
-    const prompt = buildSystemPrompt(input, PROMPT_TEMPLATE).replace('{CONTENT}', input.content);
-
-    const genAI = new GoogleGenerativeAI(apiKey);
-    const genModel = genAI.getGenerativeModel({
-      model,
-      generationConfig: { maxOutputTokens: MAX_OUTPUT_TOKENS },
-    });
-
-    let result: Awaited<ReturnType<typeof genModel.generateContent>>;
-    try {
-      result = await genModel.generateContent(prompt);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      const code = classifyError(message);
-      throw new GuardrailError(`Gemini review call failed: ${message}`, {
-        code,
-        provider: 'gemini',
-        retryable: code === 'rate_limit',
-      });
-    }
-
-    const rawOutput = result.response.text();
-    const usage = result.response.usageMetadata;
-    const costUSD = usage
-      ? (usage.promptTokenCount / 1_000_000) * COST_PER_M_INPUT +
-        (usage.candidatesTokenCount / 1_000_000) * COST_PER_M_OUTPUT
-      : undefined;
-
-    return {
-      findings: parseReviewOutput(rawOutput, 'gemini'),
-      rawOutput,
-      usage: usage
-        ? { input: usage.promptTokenCount, output: usage.candidatesTokenCount, costUSD }
-        : undefined,
-    };
-  },
-};
-
-export default geminiAdapter;