@guilz-dev/belay 0.2.0 → 0.3.0

package/dist/core/judge-config.d.ts

@@ -1,33 +1,70 @@
-import type { BelayJudgeConfig } from './config.js';
+import type { AdapterName } from '../adapters/layouts/types.js';
+import type { BelayJudgeConfig, JudgeProviderId } from './config.js';
+import { isJudgeProviderId } from './verdict/judge-catalog.js';
 export type JudgeProfileName = 'local-ollama' | 'cursor' | 'claude' | 'codex';
 export declare const JUDGE_PROFILE_LOCAL_OLLAMA: BelayJudgeConfig;
 export declare const JUDGE_PROFILE_CURSOR: BelayJudgeConfig;
 export declare const JUDGE_PROFILE_CLAUDE: BelayJudgeConfig;
 export declare const JUDGE_PROFILE_CODEX: BelayJudgeConfig;
 export declare const JUDGE_PROFILES: Record<JudgeProfileName, BelayJudgeConfig>;
+/** Default Tier1 judge catalog id for a host adapter (fresh init, no explicit judge flags). */
+export declare function defaultJudgeProviderForAdapter(adapter: AdapterName): JudgeProviderId;
 export interface ResolveJudgeConfigInput {
     judgeProfile?: JudgeProfileName;
     judgeProvider?: 'ollama' | 'openai-compatible' | 'cursor';
+    judgeProviderId?: JudgeProviderId | string;
     judgeModel?: string;
     judgeEndpoint?: string;
     existingJudge?: BelayJudgeConfig;
 }
 export declare function resolveJudgeConfig(input?: ResolveJudgeConfigInput): BelayJudgeConfig;
 export declare class CloudJudgeConsentRequiredError extends Error {
-    constructor();
+    constructor(details?: {
+        consent?: boolean;
+        key?: boolean;
+        localFallback?: boolean;
+    });
 }
 export declare class JudgeEndpointRequiredError extends Error {
-    constructor();
+    constructor(providerId?: JudgeProviderId);
 }
+export declare function isCloudJudgeConfig(judge: BelayJudgeConfig): boolean;
+export declare function hasValidCloudConsent(judge: BelayJudgeConfig): boolean;
+export declare function isImplicitLocalJudge(judge: BelayJudgeConfig): boolean;
+export declare function migrateImplicitLocalJudgeIfNeeded(existingJudge: BelayJudgeConfig, adapter: AdapterName): BelayJudgeConfig | null;
 export declare function assertJudgeEndpoint(judge: BelayJudgeConfig): void;
 export declare function resolveInitJudgeConfig(input: {
     isFresh: boolean;
     hasExplicitJudgeFlags: boolean;
     judgeProfile?: JudgeProfileName;
     judgeProvider?: 'ollama' | 'openai-compatible' | 'cursor';
+    judgeProviderId?: JudgeProviderId | string;
     judgeModel?: string;
     judgeEndpoint?: string;
     acceptCloudJudge?: boolean;
+    interactiveConsent?: boolean;
+    cloudConsentApprovalId?: string;
     existingJudge?: BelayJudgeConfig;
-    defaultJudgeProfile?: JudgeProfileName;
+    adapter?: AdapterName;
 }): BelayJudgeConfig;
+export declare function applyCloudConsent(judge: BelayJudgeConfig, params: {
+    by: string;
+}): BelayJudgeConfig;
+export interface JudgeUseOptions {
+    providerId: JudgeProviderId | string;
+    model?: string;
+    endpoint?: string;
+    timeoutMs?: number;
+    acceptCloud?: boolean;
+    cloudConsentApprovalId?: string;
+    credentialMode?: 'project' | 'apiKey';
+    keyEnv?: string;
+    interactiveTTY?: boolean;
+    interactiveConsentApproved?: boolean;
+}
+export declare function resolveJudgeUsePatch(existing: BelayJudgeConfig, options: JudgeUseOptions): {
+    judge: BelayJudgeConfig;
+    warnings: string[];
+    errors: string[];
+};
+export { isJudgeProviderId };

package/dist/core/judge-config.js

@@ -1,101 +1,307 @@
 import { normalizeJudgeProvider } from './config.js';
-export const JUDGE_PROFILE_LOCAL_OLLAMA = {
-    provider: 'ollama',
-    model: 'gemma4:e2b',
-    endpoint: 'http://localhost:11434',
-    timeoutMs: 25000,
-    keepAlive: '30m',
-};
-export const JUDGE_PROFILE_CURSOR = {
-    provider: 'openai-compatible',
-    model: 'auto',
-    endpoint: 'https://api.openai.com/v1',
-    timeoutMs: 8000,
-    keepAlive: null,
-};
-export const JUDGE_PROFILE_CLAUDE = {
-    ...JUDGE_PROFILE_CURSOR,
-};
-export const JUDGE_PROFILE_CODEX = {
-    ...JUDGE_PROFILE_CURSOR,
+import { rejectDeprecatedJudgeModelAuto } from './judge-model-policy.js';
+import { detectJudgeRuntimeCapabilities } from './judge-runtime-detection.js';
+import { catalogRequiresEndpoint, getJudgeProviderSpec, isCloudProviderId, isJudgeProviderId, JUDGE_PROVIDER_IDS, normalizeLegacyProviderId, resolveJudgeFromCatalog, } from './verdict/judge-catalog.js';
+const PROFILE_TO_PROVIDER_ID = {
+    'local-ollama': 'ollama',
+    cursor: 'cursor',
+    claude: 'claude',
+    codex: 'codex',
 };
+export const JUDGE_PROFILE_LOCAL_OLLAMA = resolveJudgeFromCatalog({
+    providerId: 'ollama',
+});
+export const JUDGE_PROFILE_CURSOR = resolveJudgeFromCatalog({
+    providerId: 'cursor',
+});
+export const JUDGE_PROFILE_CLAUDE = resolveJudgeFromCatalog({
+    providerId: 'claude',
+});
+export const JUDGE_PROFILE_CODEX = resolveJudgeFromCatalog({
+    providerId: 'codex',
+});
 export const JUDGE_PROFILES = {
     'local-ollama': JUDGE_PROFILE_LOCAL_OLLAMA,
     cursor: JUDGE_PROFILE_CURSOR,
     claude: JUDGE_PROFILE_CLAUDE,
     codex: JUDGE_PROFILE_CODEX,
 };
-export function resolveJudgeConfig(input = {}) {
+/** Default Tier1 judge catalog id for a host adapter (fresh init, no explicit judge flags). */
+export function defaultJudgeProviderForAdapter(adapter) {
+    if (adapter === 'cursor') {
+        return 'cursor';
+    }
+    if (adapter === 'claude') {
+        return 'claude';
+    }
+    if (adapter === 'codex') {
+        return 'codex';
+    }
+    return 'cursor';
+}
+function warnDeprecated(message) {
+    process.stderr.write(`Warning: ${message}\n`);
+}
+function resolveProviderIdFromFlags(input) {
+    if (input.judgeProviderId) {
+        const normalized = normalizeLegacyProviderId(String(input.judgeProviderId));
+        if (normalized) {
+            return normalized;
+        }
+    }
     if (input.judgeProvider) {
-        const provider = normalizeJudgeProvider(input.judgeProvider);
-        const base = provider === 'openai-compatible' ? openAiCompatibleBase(input) : JUDGE_PROFILE_LOCAL_OLLAMA;
-        return {
-            ...base,
-            model: input.judgeModel ?? base.model,
-            endpoint: input.judgeEndpoint?.trim() || base.endpoint,
-        };
+        const rawProvider = input.judgeProvider;
+        const provider = normalizeJudgeProvider(rawProvider);
+        if (rawProvider === 'cursor') {
+            return 'cursor';
+        }
+        if (provider === 'ollama') {
+            return 'ollama';
+        }
+        return 'codex';
+    }
+    return null;
+}
+export function resolveJudgeConfig(input = {}) {
+    if (input.judgeModel !== undefined) {
+        rejectDeprecatedJudgeModelAuto(input.judgeModel);
+    }
+    const providerIdFromFlags = resolveProviderIdFromFlags(input);
+    if (providerIdFromFlags) {
+        return resolveJudgeFromCatalog({
+            providerId: providerIdFromFlags,
+            model: input.judgeModel,
+            endpoint: input.judgeEndpoint,
+        });
     }
     if (input.judgeProfile) {
-        const profile = JUDGE_PROFILES[input.judgeProfile];
-        return {
-            ...profile,
-            model: input.judgeModel ?? profile.model,
-            endpoint: input.judgeEndpoint?.trim() || profile.endpoint,
-        };
+        warnDeprecated(`--judge-profile is deprecated; use belay config set judge.providerId <provider-id> (${JUDGE_PROVIDER_IDS.join(', ')}).`);
+        const providerId = PROFILE_TO_PROVIDER_ID[input.judgeProfile];
+        return resolveJudgeFromCatalog({
+            providerId,
+            model: input.judgeModel,
+            endpoint: input.judgeEndpoint,
+        });
     }
     if (input.existingJudge) {
         return { ...input.existingJudge };
     }
     return { ...JUDGE_PROFILE_LOCAL_OLLAMA };
 }
-function openAiCompatibleBase(input) {
-    return {
-        provider: 'openai-compatible',
-        model: input.judgeModel ?? 'auto',
-        timeoutMs: 8000,
-        endpoint: input.judgeEndpoint?.trim() ?? null,
-        keepAlive: null,
-    };
-}
 export class CloudJudgeConsentRequiredError extends Error {
-    constructor() {
-        super('Cloud judge sends redacted shell commands to an external endpoint and requires an API key in BELAY_JUDGE_API_KEY or OPENAI_API_KEY. ' +
-            'Pass --accept-cloud-judge to confirm, or use --judge-profile local-ollama for local-only Tier1.');
+    constructor(details) {
+        const parts = [];
+        if (details?.consent !== false) {
+            parts.push('Cloud judge requires recorded consent (interactive TTY with --accept-cloud, or judge_cloud_consent capability approval).');
+        }
+        if (details?.key !== false) {
+            parts.push('Set provider API keys via env or belay config credential set --key-stdin.');
+        }
+        if (details?.localFallback !== false) {
+            parts.push('Use belay config set judge.providerId ollama for local-only Tier1.');
+        }
+        super(parts.join(' '));
         this.name = 'CloudJudgeConsentRequiredError';
     }
 }
 export class JudgeEndpointRequiredError extends Error {
-    constructor() {
-        super('openai-compatible judge requires --judge-endpoint (or judge.endpoint in config). No default cloud base URL is applied.');
+    constructor(providerId) {
+        super(providerId
+            ? `${providerId} judge requires --endpoint (or judge.endpoint in config).`
+            : 'openai-compatible judge requires --judge-endpoint (or judge.endpoint in config). No default cloud base URL is applied.');
         this.name = 'JudgeEndpointRequiredError';
     }
 }
-function isCloudJudgeConfig(judge) {
-    return judge.provider === 'openai-compatible';
+export function isCloudJudgeConfig(judge) {
+    if (judge.providerId) {
+        return isCloudProviderId(judge.providerId);
+    }
+    return judge.provider === 'openai-compatible' || judge.provider === 'anthropic';
+}
+export function hasValidCloudConsent(judge) {
+    if (!judge.cloudConsent?.accepted) {
+        return false;
+    }
+    if (!judge.endpoint?.trim()) {
+        return false;
+    }
+    const providerId = judge.providerId && normalizeLegacyProviderId(judge.providerId)
+        ? normalizeLegacyProviderId(judge.providerId)
+        : judge.provider === 'ollama'
+            ? 'ollama'
+            : 'codex';
+    return (judge.cloudConsent.endpoint === judge.endpoint.trim() &&
+        normalizeLegacyProviderId(judge.cloudConsent.providerId) === providerId);
+}
+export function isImplicitLocalJudge(judge) {
+    const providerId = judge.providerId && normalizeLegacyProviderId(judge.providerId)
+        ? normalizeLegacyProviderId(judge.providerId)
+        : judge.provider === 'ollama'
+            ? 'ollama'
+            : null;
+    if (providerId !== 'ollama') {
+        return false;
+    }
+    if (judge.cloudConsent?.accepted) {
+        return false;
+    }
+    const factoryDefault = resolveJudgeFromCatalog({ providerId: 'ollama' });
+    const endpoint = judge.endpoint?.trim() ?? factoryDefault.endpoint;
+    const defaultEndpoint = factoryDefault.endpoint?.trim();
+    const endpointMatches = !judge.endpoint ||
+        endpoint === defaultEndpoint ||
+        endpoint === 'http://127.0.0.1:11434' ||
+        endpoint === 'http://localhost:11434';
+    return judge.provider === 'ollama' && judge.model === factoryDefault.model && endpointMatches;
+}
+export function migrateImplicitLocalJudgeIfNeeded(existingJudge, adapter) {
+    if (!isImplicitLocalJudge(existingJudge)) {
+        return null;
+    }
+    return applyFreshInitDefaults(resolveJudgeFromCatalog({ providerId: defaultJudgeProviderForAdapter(adapter) }));
 }
 export function assertJudgeEndpoint(judge) {
-    if (judge.provider === 'openai-compatible' && !judge.endpoint?.trim()) {
-        throw new JudgeEndpointRequiredError();
+    const providerId = judge.providerId && normalizeLegacyProviderId(judge.providerId)
+        ? normalizeLegacyProviderId(judge.providerId)
+        : judge.provider === 'ollama'
+            ? 'ollama'
+            : 'codex';
+    const transport = judge.endpoint?.trim()
+        ? 'http'
+        : (detectJudgeRuntimeCapabilities(providerId).cliTransport ?? 'http');
+    if (catalogRequiresEndpoint(providerId, { transport }) && !judge.endpoint?.trim()) {
+        throw new JudgeEndpointRequiredError(providerId);
     }
 }
+function applyFreshInitDefaults(judge) {
+    const endpoint = process.env.BELAY_JUDGE_ENDPOINT?.trim();
+    return {
+        ...judge,
+        ...(endpoint ? { endpoint } : {}),
+        credential: { mode: 'project' },
+    };
+}
 export function resolveInitJudgeConfig(input) {
     if (input.hasExplicitJudgeFlags) {
         const judge = resolveJudgeConfig({
             judgeProfile: input.judgeProfile,
             judgeProvider: input.judgeProvider,
+            judgeProviderId: input.judgeProviderId,
             judgeModel: input.judgeModel,
             judgeEndpoint: input.judgeEndpoint,
         });
-        if (isCloudJudgeConfig(judge) && !input.acceptCloudJudge) {
-            throw new CloudJudgeConsentRequiredError();
-        }
         assertJudgeEndpoint(judge);
+        if (isCloudJudgeConfig(judge) && judge.endpoint?.trim()) {
+            if (input.cloudConsentApprovalId) {
+                return applyCloudConsent(judge, {
+                    by: `capability-approval:${input.cloudConsentApprovalId}`,
+                });
+            }
+            if (input.acceptCloudJudge && input.interactiveConsent) {
+                return applyCloudConsent(judge, { by: 'tty' });
+            }
+        }
         return judge;
     }
     if (!input.isFresh && input.existingJudge) {
-        const judge = resolveJudgeConfig({ existingJudge: input.existingJudge });
-        assertJudgeEndpoint(judge);
+        return resolveJudgeConfig({ existingJudge: input.existingJudge });
+    }
+    const adapter = input.adapter ?? 'cursor';
+    const judge = resolveJudgeConfig({ judgeProviderId: defaultJudgeProviderForAdapter(adapter) });
+    return applyFreshInitDefaults(judge);
+}
+export function applyCloudConsent(judge, params) {
+    const providerId = judge.providerId && normalizeLegacyProviderId(judge.providerId)
+        ? normalizeLegacyProviderId(judge.providerId)
+        : 'codex';
+    const endpoint = judge.endpoint?.trim();
+    if (!endpoint) {
         return judge;
     }
-    return resolveJudgeConfig({ judgeProfile: input.defaultJudgeProfile ?? 'cursor' });
+    const cloudConsent = {
+        accepted: true,
+        at: new Date().toISOString(),
+        providerId,
+        endpoint,
+        by: params.by,
+    };
+    return { ...judge, cloudConsent };
+}
+export function resolveJudgeUsePatch(existing, options) {
+    const warnings = [];
+    const errors = [];
+    const normalizedId = normalizeLegacyProviderId(String(options.providerId));
+    if (!normalizedId) {
+        errors.push(`Unknown judge provider id: ${options.providerId}`);
+        return { judge: existing, warnings, errors };
+    }
+    const spec = getJudgeProviderSpec(normalizedId);
+    if (!spec) {
+        errors.push(`Unknown judge provider id: ${options.providerId}`);
+        return { judge: existing, warnings, errors };
+    }
+    let judge = resolveJudgeFromCatalog({
+        providerId: normalizedId,
+        model: options.model ?? (existing.providerId === normalizedId ? existing.model : undefined),
+        endpoint: options.endpoint !== undefined
+            ? options.endpoint
+            : existing.providerId === normalizedId
+                ? existing.endpoint
+                : undefined,
+        timeoutMs: options.timeoutMs ?? existing.timeoutMs,
+        keepAlive: existing.keepAlive,
+    });
+    if (catalogRequiresEndpoint(normalizedId, {
+        transport: judge.endpoint?.trim()
+            ? 'http'
+            : (detectJudgeRuntimeCapabilities(normalizedId).cliTransport ?? 'unavailable'),
+    }) &&
+        !judge.endpoint?.trim()) {
+        errors.push(`${normalizedId} requires --endpoint for HTTP transport.`);
+    }
+    if (options.credentialMode === 'apiKey') {
+        judge = {
+            ...judge,
+            credential: options.keyEnv
+                ? { mode: 'apiKey', ref: `env:${options.keyEnv}` }
+                : { mode: 'apiKey', ref: 'store:judge' },
+        };
+    }
+    else if (options.credentialMode === 'project') {
+        judge = { ...judge, credential: { mode: 'project' } };
+    }
+    else if (existing.credential) {
+        judge = { ...judge, credential: existing.credential };
+    }
+    const needsNewConsent = spec.isCloud &&
+        (!existing.cloudConsent?.accepted ||
+            existing.cloudConsent.endpoint !== judge.endpoint?.trim() ||
+            normalizeLegacyProviderId(existing.cloudConsent.providerId) !== normalizedId);
+    if (spec.isCloud && needsNewConsent) {
+        if (options.cloudConsentApprovalId) {
+            judge = applyCloudConsent(judge, {
+                by: `capability-approval:${options.cloudConsentApprovalId}`,
+            });
+        }
+        else if (options.acceptCloud &&
+            options.interactiveTTY &&
+            options.interactiveConsentApproved) {
+            judge = applyCloudConsent(judge, { by: 'tty' });
+        }
+        else if (options.acceptCloud && options.interactiveTTY) {
+            warnings.push('Cloud consent not recorded (--accept-cloud requires confirmation).');
+        }
+        else if (options.acceptCloud && !options.interactiveTTY) {
+            warnings.push('Cloud consent not recorded in non-interactive mode. Pass --cloud-consent-approval-id after judge_cloud_consent approval.');
+        }
+        else if (!existing.cloudConsent?.accepted) {
+            warnings.push('Cloud judge will remain disabled until consent is recorded.');
+        }
+    }
+    else if (existing.cloudConsent?.accepted && spec.isCloud) {
+        judge = { ...judge, cloudConsent: existing.cloudConsent };
+    }
+    return { judge, warnings, errors };
 }
+// Re-export for callers that validate provider ids
+export { isJudgeProviderId };

package/dist/core/judge-doctor.d.ts

@@ -1,7 +1,12 @@
 import type { BelayConfigV4 } from './config.js';
+import { type CheckJudgeModelPresenceResult, type JudgeModelDiscoveryDeps } from './judge-model-discovery.js';
 export interface JudgeDoctorResult {
     issues: string[];
     warnings: string[];
     notes: string[];
+    modelCheck?: CheckJudgeModelPresenceResult;
 }
-export declare function diagnoseJudge(config: BelayConfigV4): Promise<JudgeDoctorResult>;
+export interface DiagnoseJudgeOptions {
+    discoveryDeps?: JudgeModelDiscoveryDeps;
+}
+export declare function diagnoseJudge(config: BelayConfigV4, repoRoot?: string, options?: DiagnoseJudgeOptions): Promise<JudgeDoctorResult>;