@vibe-forge/tsconfigs 0.7.2 → 0.8.0

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerClearCommand = registerClearCommand;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+function registerClearCommand(program) {
+    program
+        .command('clear')
+        .description('Clear logs and cache of sub-agents')
+        .action(async () => {
+        // Clean main logs and caches
+        await Promise.all([
+            promises_1.default.rm('.logs', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/logs', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/caches', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/.mock/.claude/debug', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/.mock/.claude/todos', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/.mock/.claude/session-env', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/.mock/.claude/projects', { force: true, recursive: true }),
+            promises_1.default.rm('.ai/.mock/.claude-core-router/logs', {
+                force: true,
+                recursive: true
+            })
+        ]);
+        // Clean all logs directories using fast-glob patterns
+        const logsPatterns = [
+            '.ai/benchmarks/specs/**/logs',
+            '.ai/benchmarks/entities/**/logs',
+            '.ai/benchmarks/cases/**/logs'
+        ];
+        // Find all logs directories
+        const logsDirs = await (0, fast_glob_1.default)(logsPatterns, {
+            onlyDirectories: true,
+            deep: 10
+        });
+        // Remove all found logs directories (exclude main .ai/logs which we handle separately)
+        const logsDirsToRemove = logsDirs.filter((dir) => dir !== '.ai/logs' && !dir.startsWith('.ai/logs/'));
+        await Promise.all(logsDirsToRemove.map((logsDir) => promises_1.default.rm(logsDir, { force: true, recursive: true })));
+        // Recreate main directories
+        await Promise.all([
+            promises_1.default.mkdir('.ai/logs', { recursive: true }),
+            promises_1.default.mkdir('.ai/caches', { recursive: true })
+        ]);
+        // create .gitkeep files
+        await Promise.all([
+            promises_1.default.writeFile('.ai/logs/.gitkeep', ''),
+            promises_1.default.writeFile('.ai/caches/.gitkeep', '')
+        ]);
+        console.log('Clear logs and cache successfully');
+    });
+}

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerKillCommand = registerKillCommand;
+const node_process_1 = __importDefault(require("node:process"));
+const cache_1 = require("@vibe-forge/utils/cache");
+function registerKillCommand(program) {
+    program
+        .command('kill <ctxId>')
+        .description('Kill a running task (SIGKILL)')
+        .action(async (ctxId) => {
+        try {
+            // @ts-ignore
+            const detail = await (0, cache_1.getCache)(node_process_1.default.cwd(), ctxId, undefined, 'detail');
+            if (!detail) {
+                console.error(`Task ${ctxId} not found.`);
+                node_process_1.default.exit(1);
+            }
+            if (detail.status !== 'running') {
+                console.log(`Task ${ctxId} is not running (status: ${detail.status}).`);
+                return;
+            }
+            if (!detail.pid) {
+                console.error(`Task ${ctxId} has no PID recorded.`);
+                node_process_1.default.exit(1);
+            }
+            try {
+                node_process_1.default.kill(detail.pid, 'SIGKILL');
+                console.log(`Sent SIGKILL to process ${detail.pid}.`);
+            }
+            catch (e) {
+                if (e.code === 'ESRCH') {
+                    console.error(`Process ${detail.pid} not found.`);
+                }
+                else {
+                    console.error(`Failed to kill process ${detail.pid}:`, e.message);
+                    node_process_1.default.exit(1);
+                }
+            }
+        }
+        catch (e) {
+            console.error(`Error killing task:`, e.message);
+            node_process_1.default.exit(1);
+        }
+    });
+}

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

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

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerListCommand = registerListCommand;
+const cache_1 = require("@vibe-forge/utils/cache");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+function registerListCommand(program) {
+    program
+        .command('list')
+        .alias('ls')
+        .description('List historical tasks')
+        .action(async () => {
+        const cacheRoot = node_path_1.default.resolve(node_process_1.default.cwd(), '.ai/caches');
+        try {
+            await promises_1.default.access(cacheRoot);
+        }
+        catch {
+            console.log('No tasks found.');
+            return;
+        }
+        const entries = await promises_1.default.readdir(cacheRoot, { withFileTypes: true });
+        const tasks = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const ctxId = entry.name;
+                try {
+                    // @ts-ignore
+                    const detail = await (0, cache_1.getCache)(node_process_1.default.cwd(), ctxId, undefined, 'detail');
+                    if (detail) {
+                        tasks.push(detail);
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        if (tasks.length === 0) {
+            console.log('No tasks found.');
+            return;
+        }
+        // Sort by startTime desc
+        tasks.sort((a, b) => b.startTime - a.startTime);
+        console.table(tasks.map(t => ({
+            ID: t.ctxId,
+            Status: t.status,
+            Adapter: t.adapter,
+            Description: t.description
+                ? (t.description.length > 50 ? `${t.description.slice(0, 47)}...` : t.description)
+                : '',
+            Start: new Date(t.startTime).toLocaleString(),
+            PID: t.pid
+        })));
+    });
+}

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

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

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

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpCommand = registerMcpCommand;
+const node_process_1 = __importDefault(require("node:process"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const utils_js_1 = require("#~/utils.js");
+const mcpTools = __importStar(require("../mcp-tools"));
+const proxy_1 = require("../mcp-tools/proxy");
+function registerMcpCommand(program) {
+    program
+        .command('mcp')
+        .description('Start MCP server (stdio)')
+        .option('--include-tools <tools>', 'Comma-separated list of tools to include')
+        .option('--exclude-tools <tools>', 'Comma-separated list of tools to exclude')
+        .option('--include-prompts <prompts>', 'Comma-separated list of prompts to include')
+        .option('--exclude-prompts <prompts>', 'Comma-separated list of prompts to exclude')
+        .option('--include-resources <resources>', 'Comma-separated list of resources to include')
+        .option('--exclude-resources <resources>', 'Comma-separated list of resources to exclude')
+        .option('--include-category <categories>', 'Comma-separated list of categories to include')
+        .option('--exclude-category <categories>', 'Comma-separated list of categories to exclude')
+        .action(async (opts) => {
+        const parseList = (s) => s?.split(',').map((t) => t.trim()).filter(Boolean) ?? [];
+        const server = new mcp_js_1.McpServer({
+            name: 'vibe-forge',
+            version: (0, utils_js_1.getCliVersion)()
+        });
+        const proxyServer = (0, proxy_1.createFilteredRegister)(server, {
+            tools: { include: parseList(opts.includeTools), exclude: parseList(opts.excludeTools) },
+            prompts: { include: parseList(opts.includePrompts), exclude: parseList(opts.excludePrompts) },
+            resources: { include: parseList(opts.includeResources), exclude: parseList(opts.excludeResources) }
+        });
+        const categoryFilter = {
+            include: parseList(opts.includeCategory),
+            exclude: parseList(opts.excludeCategory)
+        };
+        const runType = node_process_1.default.env.__VF_PROJECT_AI_RUN_TYPE__ ?? 'cli';
+        Object.entries(mcpTools.tools).forEach(([category, register]) => {
+            if (category === 'interaction' && runType !== 'server') {
+                return;
+            }
+            if ((0, proxy_1.shouldEnableCategory)(category, categoryFilter)) {
+                register(proxyServer);
+            }
+        });
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+        console.error('MCP server started on stdio');
+    });
+}

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

@@ -0,0 +1,13 @@
+import type { Command } from 'commander';
+export declare const formatReportTimestamp: (date: Date) => string;
+export declare const resolveReportArchivePath: (cwd: string, filename?: string) => string;
+export declare const collectReportTargets: (cwd: string) => Promise<string[]>;
+export interface RunReportCommandOptions {
+    cwd?: string;
+    filename?: string;
+}
+export declare function runReportCommand(options?: RunReportCommandOptions): Promise<{
+    archivePath: string;
+    sources: string[];
+} | null>;
+export declare function registerReportCommand(program: Command): void;

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

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectReportTargets = exports.resolveReportArchivePath = exports.formatReportTimestamp = void 0;
+exports.runReportCommand = runReportCommand;
+exports.registerReportCommand = registerReportCommand;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const REPORT_TARGETS = ['.ai/logs', '.ai/caches'];
+const REPORT_MOCK_TARGETS = [
+    '.ai/.mock/.claude',
+    '.ai/.mock/.claude-code-router',
+    '.ai/.mock/.config',
+    '.ai/.mock/.codex',
+    '.ai/.mock/.vf'
+];
+const REPORT_MOCK_FILE_PREFIX = '.claude.json';
+const REPORT_TAR_EXCLUDES = [
+    '.ai/.mock/.config/**/node_modules',
+    '.ai/.mock/.config/**/node_modules/*'
+];
+const pad = (value) => String(value).padStart(2, '0');
+const formatReportTimestamp = (date) => {
+    const day = [
+        date.getUTCFullYear(),
+        pad(date.getUTCMonth() + 1),
+        pad(date.getUTCDate())
+    ].join('');
+    const time = [
+        pad(date.getUTCHours()),
+        pad(date.getUTCMinutes()),
+        pad(date.getUTCSeconds())
+    ].join('');
+    return `${day}T${time}Z`;
+};
+exports.formatReportTimestamp = formatReportTimestamp;
+const resolveReportArchivePath = (cwd, filename) => {
+    const baseName = filename?.trim()
+        ? filename.trim()
+        : `report-${(0, exports.formatReportTimestamp)(new Date())}`;
+    const archiveName = baseName.endsWith('.tar.gz') || baseName.endsWith('.tgz')
+        ? baseName
+        : `${baseName}.tar.gz`;
+    return node_path_1.default.resolve(cwd, archiveName);
+};
+exports.resolveReportArchivePath = resolveReportArchivePath;
+const collectExistingTargets = async (cwd, targets) => {
+    const availableTargets = [];
+    for (const target of targets) {
+        try {
+            await promises_1.default.access(node_path_1.default.resolve(cwd, target), node_fs_1.constants.F_OK);
+            availableTargets.push(target);
+        }
+        catch {
+            // ignore missing targets
+        }
+    }
+    return availableTargets;
+};
+const collectMockReportTargets = async (cwd) => {
+    const availableTargets = await collectExistingTargets(cwd, REPORT_MOCK_TARGETS);
+    const mockRoot = node_path_1.default.resolve(cwd, '.ai/.mock');
+    try {
+        const entries = await promises_1.default.readdir(mockRoot, { withFileTypes: true });
+        const mockFiles = entries
+            .filter(entry => entry.isFile() && (entry.name === REPORT_MOCK_FILE_PREFIX ||
+            entry.name.startsWith(`${REPORT_MOCK_FILE_PREFIX}.backup`)))
+            .map(entry => `.ai/.mock/${entry.name}`)
+            .sort((left, right) => left.localeCompare(right));
+        availableTargets.push(...mockFiles);
+    }
+    catch {
+        // ignore missing mock root
+    }
+    return availableTargets;
+};
+const collectReportTargets = async (cwd) => {
+    const availableTargets = await collectExistingTargets(cwd, REPORT_TARGETS);
+    availableTargets.push(...await collectMockReportTargets(cwd));
+    return availableTargets;
+};
+exports.collectReportTargets = collectReportTargets;
+const assertArchivePath = (cwd, archivePath, sources) => {
+    const resolvedArchivePath = node_path_1.default.resolve(archivePath);
+    for (const source of sources) {
+        const resolvedSourcePath = node_path_1.default.resolve(cwd, source);
+        if (resolvedArchivePath === resolvedSourcePath ||
+            resolvedArchivePath.startsWith(`${resolvedSourcePath}${node_path_1.default.sep}`)) {
+            throw new Error(`Report archive must not be created inside ${source}.`);
+        }
+    }
+};
+const createTarArchive = async (cwd, archivePath, sources) => {
+    await promises_1.default.mkdir(node_path_1.default.dirname(archivePath), { recursive: true });
+    await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)('tar', [
+            '-czf',
+            archivePath,
+            ...REPORT_TAR_EXCLUDES.map(pattern => `--exclude=${pattern}`),
+            '-C',
+            cwd,
+            ...sources
+        ], {
+            cwd,
+            stdio: ['ignore', 'ignore', 'pipe']
+        });
+        let stderr = '';
+        child.stderr.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on('error', (error) => {
+            const err = error;
+            if (err.code === 'ENOENT') {
+                reject(new Error('Failed to create report archive: `tar` command not found.'));
+                return;
+            }
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const message = stderr.trim();
+            reject(new Error(message
+                ? `Failed to create report archive: ${message}`
+                : `Failed to create report archive with exit code ${code ?? -1}.`));
+        });
+    });
+};
+async function runReportCommand(options = {}) {
+    const cwd = options.cwd ?? node_process_1.default.cwd();
+    const sources = await (0, exports.collectReportTargets)(cwd);
+    if (sources.length === 0) {
+        console.log('No reportable files found under .ai.');
+        return null;
+    }
+    const archivePath = (0, exports.resolveReportArchivePath)(cwd, options.filename);
+    assertArchivePath(cwd, archivePath, sources);
+    await createTarArchive(cwd, archivePath, sources);
+    console.log(`Report archive created: ${archivePath}`);
+    return {
+        archivePath,
+        sources
+    };
+}
+function registerReportCommand(program) {
+    program
+        .command('report [filename]')
+        .description('Package .ai logs, caches and selected mock data into a compressed archive')
+        .action(async (filename) => {
+        try {
+            await runReportCommand({ filename });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            node_process_1.default.exit(1);
+        }
+    });
+}

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

@@ -0,0 +1,31 @@
+import type { Command, OptionValueSource } from 'commander';
+import type { ChatMessage } from '@vibe-forge/core';
+import type { AdapterErrorData, AdapterOutputEvent } from '@vibe-forge/types';
+export declare const RUN_OUTPUT_FORMATS: readonly ["text", "json", "stream-json"];
+export type RunOutputFormat = (typeof RUN_OUTPUT_FORMATS)[number];
+export declare const createSessionExitController: <T extends {
+    kill(): void;
+}>(params?: {
+    exit?: (code: number) => never | void;
+}) => {
+    bindSession(nextSession: T): void;
+    requestExit(code: number): void;
+};
+export declare function registerRunCommand(program: Command): void;
+export declare const resolveInjectDefaultSystemPromptOption: (value: boolean | undefined, source: OptionValueSource | undefined) => boolean | undefined;
+export declare const resolveDefaultVibeForgeMcpServerOption: (value: boolean | undefined, source: OptionValueSource | undefined) => boolean | undefined;
+export declare const getPrintableAssistantText: (message: ChatMessage | undefined) => string | undefined;
+export declare const resolvePrintableStopText: (message: ChatMessage | undefined, lastAssistantText: string | undefined) => string | undefined;
+export declare const getAdapterErrorMessage: (data: AdapterErrorData) => string;
+export declare const handlePrintEvent: (input: {
+    event: AdapterOutputEvent;
+    outputFormat: RunOutputFormat;
+    lastAssistantText: string | undefined;
+    didExitAfterError: boolean;
+    log: (message: string) => void;
+    errorLog: (message: string) => void;
+    requestExit: (code: number) => void;
+}) => {
+    lastAssistantText: string | undefined;
+    didExitAfterError: boolean;
+};