@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/cli/__tests__/run.spec.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const vitest_1 = require("vitest");
+const run_js_1 = require("#~/commands/run.js");
+(0, vitest_1.describe)('run command print output', () => {
+    (0, vitest_1.it)('extracts printable assistant text from string content', () => {
+        (0, vitest_1.expect)((0, run_js_1.getPrintableAssistantText)({
+            id: 'msg-1',
+            role: 'assistant',
+            content: 'hello',
+            createdAt: Date.now()
+        })).toBe('hello');
+    });
+    (0, vitest_1.it)('ignores non-text assistant messages when choosing printable content', () => {
+        (0, vitest_1.expect)((0, run_js_1.getPrintableAssistantText)({
+            id: 'msg-2',
+            role: 'assistant',
+            content: [{
+                    type: 'tool_result',
+                    tool_use_id: 'tool-1',
+                    content: 'done'
+                }],
+            createdAt: Date.now()
+        })).toBeUndefined();
+    });
+    (0, vitest_1.it)('falls back to the last assistant text when stop has no message payload', () => {
+        (0, vitest_1.expect)((0, run_js_1.resolvePrintableStopText)(undefined, 'final answer')).toBe('final answer');
+    });
+    (0, vitest_1.it)('formats adapter error details for text output', () => {
+        (0, vitest_1.expect)((0, run_js_1.getAdapterErrorMessage)({
+            message: 'Incomplete response returned',
+            details: { reason: 'max_output_tokens' },
+            fatal: true
+        })).toContain('"reason": "max_output_tokens"');
+    });
+    (0, vitest_1.it)('treats commander default values as no CLI override for negative boolean flags', () => {
+        (0, vitest_1.expect)((0, run_js_1.resolveInjectDefaultSystemPromptOption)(true, 'default')).toBeUndefined();
+        (0, vitest_1.expect)((0, run_js_1.resolveInjectDefaultSystemPromptOption)(false, 'cli')).toBe(false);
+        (0, vitest_1.expect)((0, run_js_1.resolveDefaultVibeForgeMcpServerOption)(true, 'default')).toBeUndefined();
+        (0, vitest_1.expect)((0, run_js_1.resolveDefaultVibeForgeMcpServerOption)(false, 'cli')).toBe(false);
+    });
+    (0, vitest_1.it)('defers process exit until the session handle is bound', () => {
+        const calls = [];
+        const controller = (0, run_js_1.createSessionExitController)({
+            exit: (code) => {
+                calls.push(code);
+            }
+        });
+        let killCount = 0;
+        controller.requestExit(1);
+        (0, vitest_1.expect)(calls).toEqual([]);
+        controller.bindSession({
+            kill: () => {
+                killCount += 1;
+            }
+        });
+        (0, vitest_1.expect)(killCount).toBe(1);
+        (0, vitest_1.expect)(calls).toEqual([1]);
+    });
+    (0, vitest_1.it)('exits immediately when the session handle is already bound', () => {
+        const calls = [];
+        let killCount = 0;
+        const controller = (0, run_js_1.createSessionExitController)({
+            exit: (code) => {
+                calls.push(code);
+            }
+        });
+        controller.bindSession({
+            kill: () => {
+                killCount += 1;
+            }
+        });
+        controller.requestExit(0);
+        (0, vitest_1.expect)(killCount).toBe(1);
+        (0, vitest_1.expect)(calls).toEqual([0]);
+    });
+    (0, vitest_1.it)('prints the last assistant text for text output mode on stop', () => {
+        const log = vitest_1.vi.fn();
+        const errorLog = vitest_1.vi.fn();
+        const requestExit = vitest_1.vi.fn();
+        const stateAfterMessage = (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'message',
+                data: {
+                    id: 'msg-3',
+                    role: 'assistant',
+                    content: 'partial answer',
+                    createdAt: Date.now()
+                }
+            },
+            outputFormat: 'text',
+            lastAssistantText: undefined,
+            didExitAfterError: false,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(stateAfterMessage.lastAssistantText).toBe('partial answer');
+        (0, vitest_1.expect)(log).not.toHaveBeenCalled();
+        const stateAfterStop = (0, run_js_1.handlePrintEvent)({
+            event: { type: 'stop' },
+            outputFormat: 'text',
+            lastAssistantText: stateAfterMessage.lastAssistantText,
+            didExitAfterError: stateAfterMessage.didExitAfterError,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(stateAfterStop.lastAssistantText).toBe('partial answer');
+        (0, vitest_1.expect)(log).toHaveBeenCalledWith('partial answer');
+        (0, vitest_1.expect)(requestExit).toHaveBeenCalledWith(0);
+    });
+    (0, vitest_1.it)('prints adapter errors for fatal text-mode failures', () => {
+        const log = vitest_1.vi.fn();
+        const errorLog = vitest_1.vi.fn();
+        const requestExit = vitest_1.vi.fn();
+        const nextState = (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'error',
+                data: {
+                    message: 'fatal failure',
+                    details: { reason: 'network' },
+                    fatal: true
+                }
+            },
+            outputFormat: 'text',
+            lastAssistantText: 'previous answer',
+            didExitAfterError: false,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(errorLog).toHaveBeenCalledWith(vitest_1.expect.stringContaining('fatal failure'));
+        (0, vitest_1.expect)(requestExit).toHaveBeenCalledWith(1);
+        (0, vitest_1.expect)(nextState.didExitAfterError).toBe(true);
+    });
+    (0, vitest_1.it)('prints the stop payload as JSON for json output mode', () => {
+        const log = vitest_1.vi.fn();
+        const errorLog = vitest_1.vi.fn();
+        const requestExit = vitest_1.vi.fn();
+        const stateAfterMessage = (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'message',
+                data: {
+                    id: 'msg-4',
+                    role: 'assistant',
+                    content: 'ignored before stop',
+                    createdAt: Date.now()
+                }
+            },
+            outputFormat: 'json',
+            lastAssistantText: undefined,
+            didExitAfterError: false,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(stateAfterMessage.lastAssistantText).toBe('ignored before stop');
+        (0, vitest_1.expect)(log).not.toHaveBeenCalled();
+        (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'stop',
+                data: {
+                    id: 'msg-5',
+                    role: 'assistant',
+                    content: 'final answer',
+                    createdAt: Date.now()
+                }
+            },
+            outputFormat: 'json',
+            lastAssistantText: stateAfterMessage.lastAssistantText,
+            didExitAfterError: stateAfterMessage.didExitAfterError,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(log).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(log.mock.calls[0]?.[0]).toContain('"type": "stop"');
+        (0, vitest_1.expect)(log.mock.calls[0]?.[0]).toContain('"final answer"');
+        (0, vitest_1.expect)(requestExit).toHaveBeenCalledWith(0);
+    });
+    (0, vitest_1.it)('streams every event as JSON for stream-json output mode without suppressing stop', () => {
+        const log = vitest_1.vi.fn();
+        const errorLog = vitest_1.vi.fn();
+        const requestExit = vitest_1.vi.fn();
+        const stateAfterInit = (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'init',
+                data: {
+                    uuid: 'session-1',
+                    model: 'mock-model',
+                    version: 'test',
+                    tools: [],
+                    slashCommands: [],
+                    cwd: '/tmp/project',
+                    agents: []
+                }
+            },
+            outputFormat: 'stream-json',
+            lastAssistantText: undefined,
+            didExitAfterError: false,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(stateAfterInit.lastAssistantText).toBeUndefined();
+        const stateAfterMessage = (0, run_js_1.handlePrintEvent)({
+            event: {
+                type: 'message',
+                data: {
+                    id: 'msg-6',
+                    role: 'assistant',
+                    content: 'stream body',
+                    createdAt: Date.now()
+                }
+            },
+            outputFormat: 'stream-json',
+            lastAssistantText: stateAfterInit.lastAssistantText,
+            didExitAfterError: stateAfterInit.didExitAfterError,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, run_js_1.handlePrintEvent)({
+            event: { type: 'stop' },
+            outputFormat: 'stream-json',
+            lastAssistantText: stateAfterMessage.lastAssistantText,
+            didExitAfterError: stateAfterMessage.didExitAfterError,
+            log,
+            errorLog,
+            requestExit
+        });
+        (0, vitest_1.expect)(stateAfterMessage.lastAssistantText).toBe('stream body');
+        (0, vitest_1.expect)(log).toHaveBeenCalledTimes(3);
+        (0, vitest_1.expect)(log.mock.calls[0]?.[0]).toContain('"type": "init"');
+        (0, vitest_1.expect)(log.mock.calls[1]?.[0]).toContain('"type": "message"');
+        (0, vitest_1.expect)(log.mock.calls[2]?.[0]).toContain('"type": "stop"');
+        (0, vitest_1.expect)(requestExit).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('rejects unsupported output format values at parse time', async () => {
+        const program = new commander_1.Command();
+        program.exitOverride();
+        program.configureOutput({
+            writeErr: () => { }
+        });
+        (0, run_js_1.registerRunCommand)(program);
+        await (0, vitest_1.expect)(program.parseAsync([
+            'node',
+            'vf',
+            '--output-format',
+            'invalid-format'
+        ], { from: 'user' })).rejects.toMatchObject({
+            code: 'commander.invalidArgument'
+        });
+    });
+});

package/dist/apps/cli/__tests__/system-prompt.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/cli/__tests__/system-prompt.spec.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const system_prompt_js_1 = require("#~/system-prompt.js");
+(0, vitest_1.describe)('system prompt controls', () => {
+    (0, vitest_1.it)('keeps generated and user prompts when default injection is enabled', () => {
+        (0, vitest_1.expect)((0, system_prompt_js_1.mergeSystemPrompts)({
+            generatedSystemPrompt: 'generated prompt',
+            userSystemPrompt: 'user prompt',
+            injectDefaultSystemPrompt: true
+        })).toBe('generated prompt\n\nuser prompt');
+    });
+    (0, vitest_1.it)('omits generated prompts when default injection is disabled', () => {
+        (0, vitest_1.expect)((0, system_prompt_js_1.mergeSystemPrompts)({
+            generatedSystemPrompt: 'generated prompt',
+            userSystemPrompt: 'user prompt',
+            injectDefaultSystemPrompt: false
+        })).toBe('user prompt');
+    });
+    (0, vitest_1.it)('prefers CLI overrides over config values', () => {
+        (0, vitest_1.expect)((0, system_prompt_js_1.resolveInjectDefaultSystemPromptValue)({
+            cliValue: false,
+            projectConfig: {
+                conversation: {
+                    injectDefaultSystemPrompt: true
+                }
+            },
+            userConfig: {
+                conversation: {
+                    injectDefaultSystemPrompt: true
+                }
+            }
+        })).toBe(false);
+    });
+    (0, vitest_1.it)('prefers user config over project config when no CLI override exists', () => {
+        (0, vitest_1.expect)((0, system_prompt_js_1.resolveInjectDefaultSystemPromptValue)({
+            projectConfig: {
+                conversation: {
+                    injectDefaultSystemPrompt: true
+                }
+            },
+            userConfig: {
+                conversation: {
+                    injectDefaultSystemPrompt: false
+                }
+            }
+        })).toBe(false);
+    });
+});

package/dist/apps/cli/__tests__/task-manager.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/cli/__tests__/task-manager.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const mocks = vitest_1.vi.hoisted(() => ({
+    run: vitest_1.vi.fn(),
+    generateAdapterQueryOptions: vitest_1.vi.fn(),
+    callHook: vitest_1.vi.fn(),
+    loadInjectDefaultSystemPromptValue: vitest_1.vi.fn(),
+    mergeSystemPrompts: vitest_1.vi.fn(),
+    postSessionEvent: vitest_1.vi.fn(),
+    fetchSessionMessages: vitest_1.vi.fn(),
+    extractTextFromMessage: vitest_1.vi.fn()
+}));
+vitest_1.vi.mock('@vibe-forge/core/controllers/task', () => ({
+    generateAdapterQueryOptions: mocks.generateAdapterQueryOptions,
+    run: mocks.run
+}));
+vitest_1.vi.mock('@vibe-forge/core/hooks', () => ({
+    callHook: mocks.callHook
+}));
+vitest_1.vi.mock('#~/system-prompt.js', () => ({
+    loadInjectDefaultSystemPromptValue: mocks.loadInjectDefaultSystemPromptValue,
+    mergeSystemPrompts: mocks.mergeSystemPrompts
+}));
+vitest_1.vi.mock('#~/mcp-sync/index.js', () => ({
+    postSessionEvent: mocks.postSessionEvent,
+    fetchSessionMessages: mocks.fetchSessionMessages,
+    extractTextFromMessage: mocks.extractTextFromMessage
+}));
+(0, vitest_1.describe)('taskManager fatal error scenarios', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mocks.generateAdapterQueryOptions.mockResolvedValue([
+            {},
+            {
+                systemPrompt: undefined,
+                tools: undefined,
+                skills: undefined,
+                mcpServers: undefined
+            }
+        ]);
+        mocks.callHook.mockResolvedValue(undefined);
+        mocks.loadInjectDefaultSystemPromptValue.mockResolvedValue(true);
+        mocks.mergeSystemPrompts.mockReturnValue(undefined);
+        mocks.postSessionEvent.mockResolvedValue(undefined);
+        mocks.fetchSessionMessages.mockResolvedValue([]);
+        mocks.extractTextFromMessage.mockReturnValue('');
+    });
+    (0, vitest_1.it)('keeps the task failed when a fatal error is followed by stop', async () => {
+        const { taskManager } = await import('#~/mcp-tools/task/manager.js');
+        mocks.run.mockImplementationOnce(async (_options, adapterOptions) => {
+            const session = {
+                emit: vitest_1.vi.fn(() => {
+                    adapterOptions.onEvent({
+                        type: 'error',
+                        data: {
+                            message: 'Incomplete response returned',
+                            fatal: true
+                        }
+                    });
+                    adapterOptions.onEvent({
+                        type: 'stop',
+                        data: undefined
+                    });
+                }),
+                kill: vitest_1.vi.fn()
+            };
+            return { session };
+        });
+        await taskManager.startTask({
+            taskId: 'task-fatal-stop',
+            description: 'trigger',
+            background: false
+        });
+        const task = taskManager.getTask('task-fatal-stop');
+        (0, vitest_1.expect)(task?.status).toBe('failed');
+        (0, vitest_1.expect)(task?.logs).toContain('Incomplete response returned');
+    });
+});

package/dist/apps/cli/__tests__/tools.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/apps/cli/__tests__/tools.spec.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const wait_js_1 = __importDefault(require("#~/mcp-tools/general/wait.js"));
+const mcp_test_utils_js_1 = require("./mcp-test-utils.js");
+(0, vitest_1.describe)('mcp tools integration', () => {
+    (0, vitest_1.describe)('wait tool', () => {
+        (0, vitest_1.it)('should register wait tool', () => {
+            const tester = (0, mcp_test_utils_js_1.createToolTester)();
+            (0, wait_js_1.default)(tester.mockRegister);
+            (0, vitest_1.expect)(tester.getRegisteredTools()).toContain('wait');
+            const info = tester.getToolInfo('wait');
+            (0, vitest_1.expect)(info?.title).toBe('Wait Tool');
+        });
+        (0, vitest_1.it)('should wait for specified time', async () => {
+            const tester = (0, mcp_test_utils_js_1.createToolTester)();
+            (0, wait_js_1.default)(tester.mockRegister);
+            const start = Date.now();
+            const ms = 100;
+            const result = await tester.callTool('wait', { ms });
+            const duration = Date.now() - start;
+            (0, vitest_1.expect)(duration).toBeGreaterThanOrEqual(ms - 10); // Allow some jitter
+            (0, vitest_1.expect)(result.content[0].text).toBe(`Finished waiting for ${ms}ms`);
+        });
+        (0, vitest_1.it)('should fail validation with out-of-range input', async () => {
+            const tester = (0, mcp_test_utils_js_1.createToolTester)();
+            (0, wait_js_1.default)(tester.mockRegister);
+            // Max is 60000ms
+            await (0, vitest_1.expect)(tester.callTool('wait', { ms: 70000 }))
+                .rejects.toThrow();
+            // Min is 0ms
+            await (0, vitest_1.expect)(tester.callTool('wait', { ms: -1 }))
+                .rejects.toThrow();
+        });
+    });
+});

package/dist/apps/cli/src/cli.d.ts

@@ -0,0 +1 @@
+import './commands/@core/extra-options';

package/dist/apps/cli/src/cli.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./commands/@core/extra-options");
+const commander_1 = require("commander");
+const utils_js_1 = require("#~/utils.js");
+const benchmark_1 = require("./commands/benchmark");
+const clear_1 = require("./commands/clear");
+const kill_1 = require("./commands/kill");
+const list_1 = require("./commands/list");
+const report_1 = require("./commands/report");
+const run_1 = require("./commands/run");
+const stop_1 = require("./commands/stop");
+commander_1.program
+    .name('vf')
+    .description((0, utils_js_1.getCliDescription)())
+    .version((0, utils_js_1.getCliVersion)());
+// Register default run options
+(0, run_1.registerRunCommand)(commander_1.program);
+(0, benchmark_1.registerBenchmarkCommand)(commander_1.program);
+(0, clear_1.registerClearCommand)(commander_1.program);
+(0, list_1.registerListCommand)(commander_1.program);
+(0, report_1.registerReportCommand)(commander_1.program);
+(0, stop_1.registerStopCommand)(commander_1.program);
+(0, kill_1.registerKillCommand)(commander_1.program);
+commander_1.program.parse();

package/dist/apps/cli/src/commands/@core/extra-options.d.ts

@@ -0,0 +1 @@
+export declare const extraOptions: string[];

package/dist/apps/cli/src/commands/@core/extra-options.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extraOptions = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+// 获取通过 -- 参数传递的额外选项
+const extraOptionsStartIndex = node_process_1.default.argv.indexOf('--');
+exports.extraOptions = extraOptionsStartIndex !== -1
+    ? node_process_1.default.argv.slice(extraOptionsStartIndex + 1)
+    : [];
+if (exports.extraOptions.length > 0) {
+    // 删除 process.argv 中的额外选项
+    node_process_1.default.argv.splice(extraOptionsStartIndex, exports.extraOptions.length + 1);
+}

package/dist/apps/cli/src/commands/benchmark.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerBenchmarkCommand(program: Command): void;

package/dist/apps/cli/src/commands/benchmark.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBenchmarkCommand = registerBenchmarkCommand;
+const node_process_1 = __importDefault(require("node:process"));
+const app_runtime_1 = require("@vibe-forge/app-runtime");
+const printResult = (result) => {
+    console.table([{
+            Category: result.category,
+            Title: result.title,
+            Status: result.status,
+            Score: result.finalScore,
+            Test: result.scores.testScore,
+            Goal: result.scores.goalScore,
+            Reference: result.scores.referenceScore,
+            DurationMs: result.durationMs,
+            Timestamp: result.timestamp
+        }]);
+    if (result.issues.length > 0) {
+        console.log('\nIssues:');
+        for (const issue of result.issues) {
+            console.log(`- ${issue}`);
+        }
+    }
+};
+const createEventPrinter = () => {
+    return (event) => {
+        const target = event.title ? `${event.category}/${event.title}` : event.category;
+        console.log(`[benchmark:${target}] [${event.phase}] ${event.message}`);
+    };
+};
+function registerBenchmarkCommand(program) {
+    const benchmark = program
+        .command('benchmark')
+        .description('List and run benchmark cases');
+    benchmark
+        .command('list')
+        .description('List benchmark categories and cases')
+        .option('--category <category>', 'Filter by category')
+        .action(async (opts) => {
+        const categories = await (0, app_runtime_1.listBenchmarkCategories)();
+        const cases = await (0, app_runtime_1.listBenchmarkCases)({
+            category: opts.category
+        });
+        if (categories.length === 0) {
+            console.log('No benchmark cases found.');
+            return;
+        }
+        console.log('Categories:');
+        console.table(categories.map((item) => ({
+            Category: item.category,
+            Cases: item.caseCount,
+            Pass: item.lastStatuses.pass,
+            Partial: item.lastStatuses.partial,
+            Fail: item.lastStatuses.fail
+        })));
+        if (cases.length === 0) {
+            console.log(`No cases found for category ${opts.category}.`);
+            return;
+        }
+        console.log('\nCases:');
+        console.table(cases.map((item) => ({
+            Category: item.category,
+            Title: item.title,
+            Summary: item.summary,
+            Status: item.latestResult?.status ?? '-',
+            Score: item.latestResult?.finalScore ?? '-'
+        })));
+    });
+    benchmark
+        .command('run')
+        .description('Run one benchmark case or an entire category')
+        .requiredOption('--category <category>', 'Benchmark category')
+        .option('--title <title>', 'Benchmark title')
+        .option('--concurrency <count>', 'Category concurrency', '2')
+        .option('--adapter <adapter>', 'Adapter to use')
+        .option('--model <model>', 'Model to use')
+        .option('--system-prompt <prompt>', 'Additional system prompt')
+        .option('--permission-mode <mode>', 'Permission mode')
+        .action(async (opts) => {
+        const onEvent = createEventPrinter();
+        if (opts.title != null && opts.title !== '') {
+            const output = await (0, app_runtime_1.runBenchmarkCase)({
+                category: opts.category,
+                title: opts.title,
+                adapter: opts.adapter,
+                model: opts.model,
+                systemPrompt: opts.systemPrompt,
+                permissionMode: opts.permissionMode,
+                runtime: 'cli',
+                onEvent
+            });
+            printResult(output.result);
+            node_process_1.default.exit(output.result.status === 'fail' ? 1 : 0);
+        }
+        const concurrency = Number.parseInt(opts.concurrency ?? '2', 10);
+        const output = await (0, app_runtime_1.runBenchmarkCategory)({
+            category: opts.category,
+            concurrency: Number.isNaN(concurrency) ? 2 : concurrency,
+            adapter: opts.adapter,
+            model: opts.model,
+            systemPrompt: opts.systemPrompt,
+            permissionMode: opts.permissionMode,
+            runtime: 'cli',
+            onEvent
+        });
+        console.table(output.results.map((result) => ({
+            Title: result.title,
+            Status: result.status,
+            Score: result.finalScore,
+            Test: result.scores.testScore,
+            Goal: result.scores.goalScore,
+            Reference: result.scores.referenceScore
+        })));
+        const hasFailure = output.results.some((result) => result.status === 'fail');
+        node_process_1.default.exit(hasFailure ? 1 : 0);
+    });
+    benchmark
+        .command('show')
+        .description('Show benchmark case metadata and latest result')
+        .requiredOption('--category <category>', 'Benchmark category')
+        .requiredOption('--title <title>', 'Benchmark title')
+        .action(async (opts) => {
+        const caseItem = await (0, app_runtime_1.getBenchmarkCase)(opts);
+        if (caseItem == null) {
+            console.error(`Benchmark case not found: ${opts.category}/${opts.title}`);
+            node_process_1.default.exit(1);
+        }
+        console.log('Case:');
+        console.table([{
+                Category: caseItem.category,
+                Title: caseItem.title,
+                Summary: caseItem.summary,
+                BaseCommit: caseItem.frontmatter.baseCommit,
+                Setup: caseItem.frontmatter.setupCommand,
+                Test: caseItem.frontmatter.testCommand,
+                TimeoutSec: caseItem.frontmatter.timeoutSec
+            }]);
+        console.log('\nRFC:');
+        console.log(caseItem.rfcBody);
+        const result = await (0, app_runtime_1.readBenchmarkResult)(node_process_1.default.cwd(), opts.category, opts.title);
+        if (result == null) {
+            console.log('\nNo result.json found.');
+            return;
+        }
+        console.log('\nLatest Result:');
+        printResult(result);
+    });
+}

package/dist/apps/cli/src/commands/clear.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerClearCommand(program: Command): void;