@guilz-dev/belay 0.2.0 → 0.4.0

package/dist/core/verdict/judge-catalog.d.ts

@@ -0,0 +1,40 @@
+import type { BelayJudgeConfig, JudgeProvider } from '../config.js';
+export type JudgeProviderId = 'ollama' | 'codex' | 'claude' | 'cursor';
+/** Read-time aliases for legacy configs; never written on fresh init. */
+export declare const LEGACY_PROVIDER_ID_ALIASES: Record<string, JudgeProviderId>;
+/** Removed catalog ids; load emits a warning and best-effort canonical mapping. */
+export declare const REMOVED_JUDGE_PROVIDER_IDS: readonly ["openrouter", "custom"];
+export declare function isRemovedProviderId(id: string): boolean;
+export declare function warnRemovedProviderId(id: string): void;
+export interface JudgeProviderSpec {
+    id: JudgeProviderId;
+    driver: JudgeProvider;
+    defaultEndpoint: string | null;
+    defaultModel: string;
+    apiKeyEnvVars: string[];
+    isCloud: boolean;
+}
+export declare const JUDGE_CATALOG: Record<JudgeProviderId, JudgeProviderSpec>;
+export declare const JUDGE_PROVIDER_IDS: JudgeProviderId[];
+export declare function normalizeLegacyProviderId(id: string): JudgeProviderId | null;
+export declare function getJudgeProviderSpec(id: string): JudgeProviderSpec | null;
+export declare function isJudgeProviderId(value: string): boolean;
+export declare function inferProviderIdFromConfig(judge: Partial<BelayJudgeConfig>): JudgeProviderId;
+export interface ResolveJudgeFromCatalogInput {
+    providerId: JudgeProviderId | string;
+    model?: string;
+    endpoint?: string | null;
+    timeoutMs?: number;
+    keepAlive?: string | null;
+}
+export declare function resolveJudgeFromCatalog(input: ResolveJudgeFromCatalogInput): BelayJudgeConfig;
+export interface JudgeProviderCapabilities {
+    requiresConsent: boolean;
+    requiresEndpoint: boolean;
+    credentialPolicy: Array<'project' | 'apiKey'>;
+}
+export declare function catalogRequiresEndpoint(providerId: JudgeProviderId | string, opts?: {
+    transport?: string;
+}): boolean;
+export declare function getJudgeProviderCapabilities(providerId: JudgeProviderId | string): JudgeProviderCapabilities | null;
+export declare function isCloudProviderId(providerId: JudgeProviderId | string | undefined): boolean;

package/dist/core/verdict/judge-catalog.js

@@ -0,0 +1,148 @@
+/** Read-time aliases for legacy configs; never written on fresh init. */
+export const LEGACY_PROVIDER_ID_ALIASES = {
+    local: 'ollama',
+    openai: 'codex',
+};
+/** Removed catalog ids; load emits a warning and best-effort canonical mapping. */
+export const REMOVED_JUDGE_PROVIDER_IDS = ['openrouter', 'custom'];
+export function isRemovedProviderId(id) {
+    return REMOVED_JUDGE_PROVIDER_IDS.includes(id);
+}
+export function warnRemovedProviderId(id) {
+    process.stderr.write(`Warning: judge.providerId "${id}" was removed; migrate with belay config set judge.providerId <ollama|codex|claude|cursor>.\n`);
+}
+export const JUDGE_CATALOG = {
+    ollama: {
+        id: 'ollama',
+        driver: 'ollama',
+        defaultEndpoint: 'http://localhost:11434',
+        defaultModel: 'gemma4:e2b',
+        apiKeyEnvVars: [],
+        isCloud: false,
+    },
+    codex: {
+        id: 'codex',
+        driver: 'openai-compatible',
+        defaultEndpoint: null,
+        defaultModel: 'gpt-5.3-codex-high',
+        apiKeyEnvVars: ['OPENAI_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+    claude: {
+        id: 'claude',
+        driver: 'anthropic',
+        defaultEndpoint: null,
+        defaultModel: 'claude-sonnet-4-6',
+        apiKeyEnvVars: ['ANTHROPIC_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+    cursor: {
+        id: 'cursor',
+        driver: 'openai-compatible',
+        defaultEndpoint: null,
+        defaultModel: 'composer-2.5',
+        apiKeyEnvVars: ['CURSOR_API_KEY', 'BELAY_JUDGE_API_KEY'],
+        isCloud: true,
+    },
+};
+export const JUDGE_PROVIDER_IDS = Object.keys(JUDGE_CATALOG);
+export function normalizeLegacyProviderId(id) {
+    if (id in JUDGE_CATALOG) {
+        return id;
+    }
+    return LEGACY_PROVIDER_ID_ALIASES[id] ?? null;
+}
+export function getJudgeProviderSpec(id) {
+    const normalized = normalizeLegacyProviderId(id);
+    if (!normalized) {
+        return null;
+    }
+    return JUDGE_CATALOG[normalized];
+}
+export function isJudgeProviderId(value) {
+    return normalizeLegacyProviderId(value) !== null;
+}
+export function inferProviderIdFromConfig(judge) {
+    if (judge.providerId) {
+        const normalized = normalizeLegacyProviderId(judge.providerId);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    if (judge.provider === 'ollama') {
+        return 'ollama';
+    }
+    if (judge.provider === 'anthropic') {
+        return 'claude';
+    }
+    const endpoint = judge.endpoint?.trim().toLowerCase() ?? '';
+    if (endpoint.includes('openrouter.ai')) {
+        return 'codex';
+    }
+    if (endpoint.includes('api.openai.com')) {
+        return 'codex';
+    }
+    if (endpoint) {
+        return 'codex';
+    }
+    if (judge.provider === 'openai-compatible') {
+        const model = judge.model?.trim().toLowerCase() ?? '';
+        if (model.includes('composer')) {
+            return 'cursor';
+        }
+    }
+    return 'codex';
+}
+export function resolveJudgeFromCatalog(input) {
+    const providerId = normalizeLegacyProviderId(String(input.providerId));
+    if (!providerId) {
+        throw new Error(`Unknown judge provider id: ${input.providerId}`);
+    }
+    const spec = JUDGE_CATALOG[providerId];
+    const model = input.model?.trim() || spec.defaultModel;
+    const endpoint = input.endpoint !== undefined ? input.endpoint?.trim() || null : spec.defaultEndpoint;
+    return {
+        provider: spec.driver,
+        providerId: spec.id,
+        model,
+        endpoint,
+        timeoutMs: input.timeoutMs ?? (spec.isCloud ? 8000 : 25000),
+        keepAlive: spec.driver === 'ollama' ? (input.keepAlive ?? '30m') : null,
+    };
+}
+export function catalogRequiresEndpoint(providerId, opts) {
+    const normalized = normalizeLegacyProviderId(String(providerId));
+    if (!normalized || normalized === 'ollama') {
+        return false;
+    }
+    const transport = opts?.transport;
+    if (!transport) {
+        return false;
+    }
+    if (transport.endsWith('-cli') || transport === 'ollama-http') {
+        return false;
+    }
+    return transport === 'http';
+}
+export function getJudgeProviderCapabilities(providerId) {
+    const normalized = normalizeLegacyProviderId(String(providerId));
+    if (!normalized) {
+        return null;
+    }
+    const spec = JUDGE_CATALOG[normalized];
+    return {
+        requiresConsent: spec.isCloud,
+        requiresEndpoint: catalogRequiresEndpoint(normalized, { transport: 'http' }),
+        credentialPolicy: ['project', 'apiKey'],
+    };
+}
+export function isCloudProviderId(providerId) {
+    if (!providerId) {
+        return false;
+    }
+    const normalized = normalizeLegacyProviderId(providerId);
+    if (!normalized) {
+        return false;
+    }
+    return JUDGE_CATALOG[normalized].isCloud;
+}

package/dist/core/verdict/judge-cli-fingerprint.d.ts

@@ -0,0 +1,5 @@
+import type { JudgeProviderId } from './judge-catalog.js';
+export type CliFingerprintResolver = (providerId: Exclude<JudgeProviderId, 'ollama'>) => Promise<string>;
+export declare function setCliFingerprintResolverForTests(resolver: CliFingerprintResolver | null): void;
+export declare function resolveCliVersionFingerprint(providerId: Exclude<JudgeProviderId, 'ollama'>, timeoutMs?: number): Promise<string>;
+export declare function resetCliFingerprintCache(): void;

package/dist/core/verdict/judge-cli-fingerprint.js

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process';
+const CLI_BINARIES = {
+    codex: 'codex',
+    cursor: 'cursor-agent',
+    claude: 'claude',
+};
+let fingerprintResolver = null;
+const fingerprintCache = new Map();
+export function setCliFingerprintResolverForTests(resolver) {
+    fingerprintResolver = resolver;
+    fingerprintCache.clear();
+}
+async function runVersionProbe(binary, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            reject(new Error(`${binary} --version timed out`));
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            const output = (stdout || stderr).trim();
+            if (code === 0 && output) {
+                resolve(output.split(/\r?\n/)[0]?.trim() || output);
+                return;
+            }
+            reject(new Error(stderr.trim() || `${binary} --version exited with code ${code ?? 'unknown'}`));
+        });
+    });
+}
+export async function resolveCliVersionFingerprint(providerId, timeoutMs = 3_000) {
+    const cacheKey = providerId;
+    const cached = fingerprintCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    if (fingerprintResolver) {
+        const resolved = await fingerprintResolver(providerId);
+        fingerprintCache.set(cacheKey, resolved);
+        return resolved;
+    }
+    const binary = CLI_BINARIES[providerId];
+    const version = await runVersionProbe(binary, timeoutMs);
+    fingerprintCache.set(cacheKey, version);
+    return version;
+}
+export function resetCliFingerprintCache() {
+    fingerprintCache.clear();
+}

package/dist/core/verdict/judge-cli.d.ts

@@ -0,0 +1,46 @@
+import type { ScrubOptions } from '../types.js';
+import { parseTier1Json, type TracedTier1Judge } from './judge.js';
+import type { JudgeProviderId } from './judge-catalog.js';
+import type { BelayJudgeRuntimeConfig } from './judge-runtime-config.js';
+export interface CliJudgeOptions {
+    providerId: JudgeProviderId;
+    modelRequested: string;
+    modelResolved: string;
+    timeoutMs?: number;
+    sensitivePaths: string[];
+    scrubOptions: ScrubOptions;
+    runCliCommand?: CliJudgeRunCommand;
+    runtime?: BelayJudgeRuntimeConfig;
+    repoRoot?: string;
+    stateDir?: string;
+    judgeMode?: string;
+}
+export interface CliInvocation {
+    binary: string;
+    args: string[];
+    stdin?: string;
+}
+export type CliJudgeRunCommand = (invocation: CliInvocation, timeoutMs: number) => Promise<string>;
+export type CliRunErrorKind = 'timeout' | 'spawn_error' | 'exit_nonzero';
+export declare class CliRunError extends Error {
+    kind: CliRunErrorKind;
+    exitCode?: number;
+    stderr?: string;
+    stdout?: string;
+    command?: string;
+    constructor(kind: CliRunErrorKind, message: string, details?: {
+        exitCode?: number;
+        stderr?: string;
+        stdout?: string;
+        command?: string;
+    });
+}
+export declare function buildCliInvocation(providerId: Exclude<JudgeProviderId, 'ollama'>, prompt: string, model: string): CliInvocation;
+export declare function parseCliJudgeOutput(providerId: Exclude<JudgeProviderId, 'ollama'>, raw: string): ReturnType<typeof parseTier1Json>;
+export declare function runCliJsonWithTimeouts(invocation: CliInvocation, budgets: {
+    connectTimeoutMs?: number;
+    evalTimeoutMs: number;
+}): Promise<string>;
+export declare function createCodexCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;
+export declare function createCursorCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;
+export declare function createClaudeCliJudge(options: Omit<CliJudgeOptions, 'providerId'>): TracedTier1Judge;