@phuetz/code-buddy 1.1.0 → 1.3.0

package/dist/agent/hermes-runtime-lifecycle.js

@@ -0,0 +1,468 @@
+/**
+ * Hibernate/wake lifecycle semantics for Hermes runtime backends.
+ *
+ * Each backend gets a strategy that maps to concrete CLI invocations:
+ *   - local/wsl/os-sandbox/singularity: lifecycle unsupported (always running or job-based)
+ *   - docker: pause / unpause / inspect
+ *   - ssh: connection close / reconnect
+ *   - modal: app stop / run
+ *   - daytona: workspace stop / start
+ *   - vercel-sandbox: unsupported (no lifecycle API)
+ */
+import os from 'os';
+import { spawnSync } from 'child_process';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const UNSUPPORTED_BACKEND_IDS = new Set([
+    'local',
+    'wsl',
+    'os-sandbox',
+    'singularity',
+    'vercel-sandbox',
+]);
+const DEFAULT_TIMEOUT_MS = 30_000;
+const BACKEND_LABELS = {
+    'local': 'Local process',
+    'docker': 'Docker sandbox',
+    'wsl': 'WSL',
+    'os-sandbox': 'Native OS sandbox',
+    'ssh': 'SSH remote shell',
+    'singularity': 'Singularity/Apptainer',
+    'modal': 'Modal',
+    'daytona': 'Daytona',
+    'vercel-sandbox': 'Vercel Sandbox',
+};
+const ALL_BACKEND_IDS = Object.keys(BACKEND_LABELS);
+function runSpawn(command, args, env, timeoutMs) {
+    try {
+        const result = spawnSync(command, args, {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            windowsHide: true,
+        });
+        const stdout = decodeBuffer(result.stdout).trim();
+        const stderr = decodeBuffer(result.stderr).trim();
+        return {
+            exitCode: result.status,
+            ok: !result.error && result.status === 0,
+            stdout,
+            stderr,
+        };
+    }
+    catch {
+        return { exitCode: null, ok: false, stdout: '', stderr: '' };
+    }
+}
+function decodeBuffer(value) {
+    if (!value)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    return value.toString('utf8');
+}
+function unsupportedAction(backendId, action, durationMs) {
+    return {
+        backendId,
+        action,
+        result: 'unsupported',
+        state: 'unsupported',
+        detail: `${BACKEND_LABELS[backendId] ?? backendId} does not support managed lifecycle operations.`,
+        durationMs,
+    };
+}
+function failedAction(backendId, action, detail, durationMs) {
+    return {
+        backendId,
+        action,
+        result: 'failed',
+        state: 'unknown',
+        detail,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Docker lifecycle
+// ---------------------------------------------------------------------------
+function dockerHibernate(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'hibernate', 'containerId is required for docker hibernate.', 0);
+    }
+    const result = runSpawn('docker', ['pause', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'docker',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Container ${containerId} paused.`,
+            durationMs,
+        };
+    }
+    return failedAction('docker', 'hibernate', result.stderr || `docker pause failed (exit ${result.exitCode}).`, durationMs);
+}
+function dockerWake(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'wake', 'containerId is required for docker wake.', 0);
+    }
+    const result = runSpawn('docker', ['unpause', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'docker',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Container ${containerId} unpaused.`,
+            durationMs,
+        };
+    }
+    return failedAction('docker', 'wake', result.stderr || `docker unpause failed (exit ${result.exitCode}).`, durationMs);
+}
+function dockerStatus(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'status', 'containerId is required for docker status.', 0);
+    }
+    const result = runSpawn('docker', ['inspect', '--format', '{{.State.Status}}', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('docker', 'status', result.stderr || `docker inspect failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const raw = result.stdout.trim().toLowerCase();
+    const state = dockerStatusToLifecycleState(raw);
+    return {
+        backendId: 'docker',
+        action: 'status',
+        result: 'success',
+        state,
+        detail: `Container ${containerId} status: ${raw}.`,
+        durationMs,
+    };
+}
+function dockerStatusToLifecycleState(dockerState) {
+    switch (dockerState) {
+        case 'running':
+            return 'running';
+        case 'paused':
+            return 'hibernated';
+        case 'restarting':
+            return 'starting';
+        case 'removing':
+        case 'exited':
+        case 'dead':
+            return 'stopping';
+        default:
+            return 'unknown';
+    }
+}
+// ---------------------------------------------------------------------------
+// SSH lifecycle
+// ---------------------------------------------------------------------------
+function sshHibernate(_sshHost, _env, _timeoutMs) {
+    // SSH "hibernate" = drop connection. We don't manage persistent connections,
+    // so we just report success — the SSH session will close naturally.
+    return {
+        backendId: 'ssh',
+        action: 'hibernate',
+        result: 'success',
+        state: 'hibernated',
+        detail: 'SSH connection released; keepalive stopped.',
+        durationMs: 0,
+    };
+}
+function sshWake(sshHost, env, timeoutMs) {
+    const start = Date.now();
+    if (!sshHost) {
+        return failedAction('ssh', 'wake', 'sshHost is required for SSH wake.', 0);
+    }
+    const result = runSpawn('ssh', ['-T', '-o', 'ConnectTimeout=10', sshHost, 'true'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'ssh',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `SSH connection to ${sshHost} verified.`,
+            durationMs,
+        };
+    }
+    return failedAction('ssh', 'wake', result.stderr || `SSH connection to ${sshHost} failed (exit ${result.exitCode}).`, durationMs);
+}
+function sshStatus(sshHost, env, timeoutMs) {
+    const start = Date.now();
+    if (!sshHost) {
+        return failedAction('ssh', 'status', 'sshHost is required for SSH status.', 0);
+    }
+    const result = runSpawn('ssh', ['-T', '-o', 'ConnectTimeout=5', sshHost, 'true'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'ssh',
+            action: 'status',
+            result: 'success',
+            state: 'running',
+            detail: `SSH host ${sshHost} is reachable.`,
+            durationMs,
+        };
+    }
+    return {
+        backendId: 'ssh',
+        action: 'status',
+        result: 'success',
+        state: 'hibernated',
+        detail: `SSH host ${sshHost} is not reachable: ${result.stderr || `exit ${result.exitCode}`}.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Modal lifecycle
+// ---------------------------------------------------------------------------
+function modalHibernate(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'hibernate', 'modalApp is required for Modal hibernate.', 0);
+    }
+    const result = runSpawn('modal', ['app', 'stop', modalApp], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'modal',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Modal app ${modalApp} stopped.`,
+            durationMs,
+        };
+    }
+    return failedAction('modal', 'hibernate', result.stderr || `modal app stop failed (exit ${result.exitCode}).`, durationMs);
+}
+function modalWake(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'wake', 'modalApp is required for Modal wake.', 0);
+    }
+    const result = runSpawn('modal', ['run', modalApp], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'modal',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Modal app ${modalApp} started.`,
+            durationMs,
+        };
+    }
+    return failedAction('modal', 'wake', result.stderr || `modal run failed (exit ${result.exitCode}).`, durationMs);
+}
+function modalStatus(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'status', 'modalApp is required for Modal status.', 0);
+    }
+    const result = runSpawn('modal', ['app', 'list'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('modal', 'status', result.stderr || `modal app list failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const isRunning = result.stdout.includes(modalApp);
+    return {
+        backendId: 'modal',
+        action: 'status',
+        result: 'success',
+        state: isRunning ? 'running' : 'hibernated',
+        detail: isRunning
+            ? `Modal app ${modalApp} appears in app list.`
+            : `Modal app ${modalApp} not found in app list.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Daytona lifecycle
+// ---------------------------------------------------------------------------
+function daytonaHibernate(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'hibernate', 'daytonaWorkspace is required for Daytona hibernate.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'stop', workspace], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'daytona',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Daytona workspace ${workspace} stopped.`,
+            durationMs,
+        };
+    }
+    return failedAction('daytona', 'hibernate', result.stderr || `daytona workspace stop failed (exit ${result.exitCode}).`, durationMs);
+}
+function daytonaWake(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'wake', 'daytonaWorkspace is required for Daytona wake.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'start', workspace], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'daytona',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Daytona workspace ${workspace} started.`,
+            durationMs,
+        };
+    }
+    return failedAction('daytona', 'wake', result.stderr || `daytona workspace start failed (exit ${result.exitCode}).`, durationMs);
+}
+function daytonaStatus(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'status', 'daytonaWorkspace is required for Daytona status.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'list'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('daytona', 'status', result.stderr || `daytona workspace list failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const isRunning = result.stdout.includes(workspace);
+    return {
+        backendId: 'daytona',
+        action: 'status',
+        result: 'success',
+        state: isRunning ? 'running' : 'hibernated',
+        detail: isRunning
+            ? `Daytona workspace ${workspace} appears in workspace list.`
+            : `Daytona workspace ${workspace} not found in workspace list.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Execute a lifecycle action on a backend.
+ */
+export function executeBackendLifecycleAction(backendId, action, options = {}) {
+    const env = options.env ?? process.env;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (UNSUPPORTED_BACKEND_IDS.has(backendId)) {
+        return unsupportedAction(backendId, action, 0);
+    }
+    if (!BACKEND_LABELS[backendId]) {
+        return failedAction(backendId, action, `Unknown backend: ${backendId}.`, 0);
+    }
+    switch (backendId) {
+        case 'docker': {
+            const containerId = options.containerId ?? env.CODEBUDDY_DOCKER_CONTAINER ?? '';
+            if (action === 'hibernate')
+                return dockerHibernate(containerId, env, timeoutMs);
+            if (action === 'wake')
+                return dockerWake(containerId, env, timeoutMs);
+            return dockerStatus(containerId, env, timeoutMs);
+        }
+        case 'ssh': {
+            const sshHost = options.sshHost
+                ?? env.CODEBUDDY_SSH_HOST
+                ?? env.SSH_HOST
+                ?? env.CODEBUDDY_REMOTE_HOST
+                ?? '';
+            if (action === 'hibernate')
+                return sshHibernate(sshHost, env, timeoutMs);
+            if (action === 'wake')
+                return sshWake(sshHost, env, timeoutMs);
+            return sshStatus(sshHost, env, timeoutMs);
+        }
+        case 'modal': {
+            const modalApp = options.modalApp ?? env.CODEBUDDY_MODAL_APP ?? '';
+            if (action === 'hibernate')
+                return modalHibernate(modalApp, env, timeoutMs);
+            if (action === 'wake')
+                return modalWake(modalApp, env, timeoutMs);
+            return modalStatus(modalApp, env, timeoutMs);
+        }
+        case 'daytona': {
+            const workspace = options.daytonaWorkspace ?? env.CODEBUDDY_DAYTONA_WORKSPACE ?? '';
+            if (action === 'hibernate')
+                return daytonaHibernate(workspace, env, timeoutMs);
+            if (action === 'wake')
+                return daytonaWake(workspace, env, timeoutMs);
+            return daytonaStatus(workspace, env, timeoutMs);
+        }
+        default:
+            return unsupportedAction(backendId, action, 0);
+    }
+}
+/**
+ * Build a lifecycle status report for all backends.
+ */
+export function buildBackendLifecycleStatusReport(options = {}) {
+    const now = options.now ?? (() => new Date());
+    const entries = ALL_BACKEND_IDS.map((backendId) => {
+        const lifecycleSupported = !UNSUPPORTED_BACKEND_IDS.has(backendId);
+        if (!lifecycleSupported) {
+            return {
+                backendId,
+                label: BACKEND_LABELS[backendId] ?? backendId,
+                lifecycleSupported: false,
+                state: 'unsupported',
+                detail: `${BACKEND_LABELS[backendId] ?? backendId} does not support managed lifecycle operations.`,
+            };
+        }
+        const statusAction = executeBackendLifecycleAction(backendId, 'status', options);
+        return {
+            backendId,
+            label: BACKEND_LABELS[backendId] ?? backendId,
+            lifecycleSupported: true,
+            state: statusAction.state,
+            detail: statusAction.detail,
+        };
+    });
+    return {
+        kind: 'hermes_runtime_lifecycle_status',
+        schemaVersion: 1,
+        generatedAt: now().toISOString(),
+        platform: os.platform(),
+        arch: os.arch(),
+        backends: entries,
+    };
+}
+/**
+ * Render a lifecycle status report as human-readable text.
+ */
+export function renderBackendLifecycleStatusReport(report) {
+    const lines = [
+        'Hermes runtime lifecycle status',
+        `Platform: ${report.platform}/${report.arch}`,
+        `Generated: ${report.generatedAt}`,
+        '',
+        'Backends:',
+        ...report.backends.map((entry) => {
+            const supported = entry.lifecycleSupported ? 'lifecycle' : 'no-lifecycle';
+            return `  ${entry.backendId}: ${entry.state} (${supported}) — ${entry.detail}`;
+        }),
+    ];
+    return lines.join('\n');
+}
+/**
+ * Render a single lifecycle action result as human-readable text.
+ */
+export function renderBackendLifecycleAction(action) {
+    const lines = [
+        `Hermes runtime lifecycle ${action.action} (${action.backendId}): ${action.result}`,
+        `  State: ${action.state}`,
+        `  Detail: ${action.detail}`,
+        `  Duration: ${action.durationMs}ms`,
+    ];
+    return lines.join('\n');
+}
+//# sourceMappingURL=hermes-runtime-lifecycle.js.map

package/dist/agent/middleware/index.d.ts

@@ -18,3 +18,4 @@ export type { AutoRepairConfig } from './auto-repair-middleware.js';
 export { QualityGateMiddleware, createQualityGateMiddleware } from './quality-gate-middleware.js';
 export type { QualityGateConfig, QualityGate } from './quality-gate-middleware.js';
 export { ReasoningMiddleware, createReasoningMiddleware } from './reasoning-middleware.js';
+export { VisualValidationMiddleware } from './visual-validation-middleware.js';

package/dist/agent/middleware/index.js

@@ -14,4 +14,5 @@ export { WorkflowGuardMiddleware } from './workflow-guard.js';
 export { AutoRepairMiddleware, createAutoRepairMiddleware } from './auto-repair-middleware.js';
 export { QualityGateMiddleware, createQualityGateMiddleware } from './quality-gate-middleware.js';
 export { ReasoningMiddleware, createReasoningMiddleware } from './reasoning-middleware.js';
+export { VisualValidationMiddleware } from './visual-validation-middleware.js';
 //# sourceMappingURL=index.js.map

package/dist/agent/middleware/visual-validation-middleware.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Visual Validation Middleware
+ *
+ * Checks if the agent has saved an Office document (Excel, PowerPoint, Word).
+ * If so, it warns the agent to consider running a visual validation step
+ * using `snapshot_with_screenshot` to verify the layout, fonts, and alignments.
+ *
+ * Priority 156
+ */
+import type { ConversationMiddleware, MiddlewareContext, MiddlewareResult } from './types.js';
+export declare class VisualValidationMiddleware implements ConversationMiddleware {
+    readonly name = "visual-validation";
+    readonly priority = 156;
+    private hasWarnedForFiles;
+    afterTurn(context: MiddlewareContext): Promise<MiddlewareResult>;
+    private getRecentlySavedOfficeFiles;
+}

package/dist/agent/middleware/visual-validation-middleware.js

@@ -0,0 +1,67 @@
+/**
+ * Visual Validation Middleware
+ *
+ * Checks if the agent has saved an Office document (Excel, PowerPoint, Word).
+ * If so, it warns the agent to consider running a visual validation step
+ * using `snapshot_with_screenshot` to verify the layout, fonts, and alignments.
+ *
+ * Priority 156
+ */
+import { logger } from '../../utils/logger.js';
+export class VisualValidationMiddleware {
+    name = 'visual-validation';
+    priority = 156;
+    hasWarnedForFiles = new Set();
+    async afterTurn(context) {
+        if (process.platform !== 'win32') {
+            return { action: 'continue' };
+        }
+        const savedFiles = this.getRecentlySavedOfficeFiles(context);
+        if (savedFiles.length === 0) {
+            return { action: 'continue' };
+        }
+        // Filter out files we already warned about
+        const newFiles = savedFiles.filter((f) => !this.hasWarnedForFiles.has(f));
+        if (newFiles.length === 0) {
+            return { action: 'continue' };
+        }
+        for (const f of newFiles) {
+            this.hasWarnedForFiles.add(f);
+        }
+        logger.info('Visual validation middleware triggered', {
+            files: newFiles,
+        });
+        return {
+            action: 'warn',
+            message: `You just saved the following Office document(s): ${newFiles.join(', ')}.\n` +
+                `To ensure the best quality, please open the document and use the \`snapshot_with_screenshot\` action via \`computer_control\` to visually verify the layout, fonts, and alignment, and auto-correct any visual issues.`,
+        };
+    }
+    getRecentlySavedOfficeFiles(context) {
+        const files = new Set();
+        // Scan recent tool calls in the context history
+        for (let i = context.history.length - 1; i >= Math.max(0, context.history.length - 10); i--) {
+            const msg = context.history[i];
+            if (!msg || !msg.toolCalls)
+                continue;
+            for (const call of msg.toolCalls) {
+                if (call.function.name === 'computer_control') {
+                    try {
+                        const args = JSON.parse(call.function.arguments);
+                        const action = args.action;
+                        if (['excel_save_workbook', 'powerpoint_save_presentation', 'word_save_document'].includes(action)) {
+                            if (args.saveAsPath || args.filePath) {
+                                files.add(args.saveAsPath || args.filePath);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+            }
+        }
+        return Array.from(files);
+    }
+}
+//# sourceMappingURL=visual-validation-middleware.js.map

package/dist/agent/model-benchmark.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Live model benchmarking for Tailnet Ollama peers.
+ *
+ * Measures actual request latency and simple compliance signals so the router
+ * can prefer the best network model instead of relying on a static ordering.
+ * The benchmark is intentionally lightweight: a few objective prompts, temp=0,
+ * streamed completions, and a persisted score cache that the model-tier ladder
+ * can use to rank candidates.
+ */
+export interface ModelBenchmarkCandidate {
+    model: string;
+    baseUrl: string;
+    label?: string;
+}
+export interface ModelBenchmarkPrompt {
+    name: string;
+    prompt: string;
+    maxTokens: number;
+    validate: (output: string) => boolean;
+}
+export interface ModelBenchmarkRun {
+    promptName: string;
+    success: boolean;
+    compliance: boolean;
+    ttftMs: number;
+    totalMs: number;
+    outputChars: number;
+    outputTokensEstimate: number;
+    error?: string;
+    outputPreview?: string;
+}
+export interface ModelBenchmarkSummary {
+    runs: number;
+    successes: number;
+    complianceRate: number;
+    avgTtftMs: number;
+    avgTotalMs: number;
+    avgOutputTokensEstimate: number;
+    score: number;
+}
+export interface ModelBenchmarkReport {
+    candidate: ModelBenchmarkCandidate;
+    runs: ModelBenchmarkRun[];
+    summary: ModelBenchmarkSummary;
+}
+export interface ModelBenchmarkIndexEntry {
+    model: string;
+    baseUrl: string;
+    label?: string;
+    score: number;
+    complianceRate: number;
+    avgTtftMs: number;
+    avgTotalMs: number;
+    updatedAt: string;
+}
+export interface ModelBenchmarkIndex {
+    updatedAt: string;
+    suite: string;
+    entries: ModelBenchmarkIndexEntry[];
+}
+export interface BenchmarkExecutionOptions {
+    runs?: number;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+}
+export interface BenchmarkSuiteOptions extends BenchmarkExecutionOptions {
+    promptSet?: BenchmarkPromptSetName;
+}
+export type BenchmarkPromptSetName = 'balanced' | 'coding' | 'latency';
+export declare const BENCHMARK_PROMPT_SETS: Record<BenchmarkPromptSetName, ModelBenchmarkPrompt[]>;
+export declare function defaultBenchmarkIndexPath(homeDir?: string): string;
+export declare function benchmarkCandidateKey(candidate: ModelBenchmarkCandidate): string;
+export declare function benchmarkCandidates(candidates: ModelBenchmarkCandidate[], options?: BenchmarkSuiteOptions): Promise<ModelBenchmarkReport[]>;
+export declare function summarizeBenchmarkRuns(runs: ModelBenchmarkRun[]): ModelBenchmarkSummary;
+export declare function writeBenchmarkIndex(reports: ModelBenchmarkReport[], suite: string, indexPath?: string): Promise<ModelBenchmarkIndex>;
+export declare function loadBenchmarkIndex(indexPath?: string): Promise<ModelBenchmarkIndex | null>;
+export declare function loadBenchmarkScoreMap(indexPath?: string): Promise<Map<string, number>>;