@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/apps/cli/src/mcp-tools/task/manager.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskManager = void 0;
+const node_process_1 = __importDefault(require("node:process"));
+const task_1 = require("@vibe-forge/core/controllers/task");
+const hooks_1 = require("@vibe-forge/core/hooks");
+const index_js_1 = require("#~/mcp-sync/index.js");
+const system_prompt_js_1 = require("#~/system-prompt.js");
+class TaskManager {
+    tasks = new Map();
+    async startTask(options) {
+        const { taskId, adapter, description, type, name, permissionMode, background = true, enableServerSync } = options;
+        // Initialize Task Info
+        const taskInfo = {
+            taskId,
+            adapter,
+            description,
+            type,
+            name,
+            permissionMode,
+            background,
+            status: 'running',
+            logs: [],
+            createdAt: Date.now()
+        };
+        if (enableServerSync) {
+            taskInfo.serverSync = {
+                sessionId: taskId,
+                lastEventIndex: 0,
+                seenMessageIds: new Set()
+            };
+        }
+        this.tasks.set(taskId, taskInfo);
+        try {
+            // Resolve Config
+            const promptType = type !== 'default' ? type : undefined;
+            const promptName = name;
+            const promptCWD = node_process_1.default.cwd();
+            const [data, resolvedConfig] = await (0, task_1.generateAdapterQueryOptions)(promptType, promptName, promptCWD);
+            const env = {
+                ...node_process_1.default.env,
+                __VF_PROJECT_AI_CTX_ID__: node_process_1.default.env.__VF_PROJECT_AI_CTX_ID__ ?? taskId
+            };
+            await (0, hooks_1.callHook)('GenerateSystemPrompt', {
+                cwd: promptCWD,
+                sessionId: taskId,
+                type: promptType,
+                name: promptName,
+                data
+            }, env);
+            const injectDefaultSystemPrompt = await (0, system_prompt_js_1.loadInjectDefaultSystemPromptValue)(promptCWD);
+            // Start Task
+            const ctxId = node_process_1.default.env.__VF_PROJECT_AI_CTX_ID__ ?? taskId;
+            const { session } = await (0, task_1.run)({
+                adapter,
+                cwd: node_process_1.default.cwd(),
+                env: {
+                    ...node_process_1.default.env,
+                    __VF_PROJECT_AI_CTX_ID__: ctxId
+                }
+            }, {
+                type: 'create',
+                runtime: 'mcp',
+                mode: 'stream',
+                sessionId: taskId,
+                systemPrompt: (0, system_prompt_js_1.mergeSystemPrompts)({
+                    generatedSystemPrompt: resolvedConfig.systemPrompt,
+                    injectDefaultSystemPrompt
+                }),
+                permissionMode,
+                tools: resolvedConfig.tools,
+                skills: resolvedConfig.skills,
+                mcpServers: resolvedConfig.mcpServers,
+                promptAssetIds: resolvedConfig.promptAssetIds,
+                onEvent: (event) => {
+                    this.handleEvent(taskId, event);
+                }
+            });
+            // Store session for control
+            const task = this.tasks.get(taskId);
+            if (task) {
+                task.session = session;
+                // Send initial prompt (description)
+                session.emit({
+                    type: 'message',
+                    content: [{ type: 'text', text: description }]
+                });
+                this.startServerPolling(taskId);
+            }
+            if (!background) {
+                // Wait for completion
+                await new Promise((resolve) => {
+                    const task = this.tasks.get(taskId);
+                    if (!task) {
+                        resolve();
+                        return;
+                    }
+                    // Check if already finished
+                    if (task.status !== 'running') {
+                        resolve();
+                        return;
+                    }
+                    // Register callback
+                    task.onStop = resolve;
+                });
+                return { taskId, logs: taskInfo.logs };
+            }
+        }
+        catch (err) {
+            const task = this.tasks.get(taskId);
+            if (task) {
+                task.status = 'failed';
+                task.logs.push(`Failed to start task: ${err instanceof Error ? err.message : String(err)}`);
+                task.onStop?.();
+            }
+            throw err;
+        }
+        return { taskId };
+    }
+    handleEvent(taskId, event) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return;
+        void this.syncEvent(task, event);
+        switch (event.type) {
+            case 'message': {
+                const message = event.data;
+                if (message?.id) {
+                    task.serverSync?.seenMessageIds.add(message.id);
+                }
+                if (message?.role === 'assistant' && message.id) {
+                    if (task.serverSync) {
+                        task.serverSync.lastAssistantMessageId = message.id;
+                    }
+                }
+                const content = event.data.content;
+                let text = '';
+                if (typeof content === 'string') {
+                    text = content;
+                }
+                else if (Array.isArray(content)) {
+                    text = content.map(c => c.type === 'text' ? c.text : '').join('');
+                }
+                if (text) {
+                    task.logs.push(text);
+                }
+                break;
+            }
+            case 'error': {
+                task.logs.push(event.data.message);
+                if (event.data.fatal !== false) {
+                    task.status = 'failed';
+                    this.stopServerPolling(taskId);
+                    task.onStop?.();
+                }
+                break;
+            }
+            case 'stop': {
+                if (task.status === 'failed') {
+                    this.stopServerPolling(taskId);
+                    task.onStop?.();
+                    break;
+                }
+                task.status = 'completed';
+                this.stopServerPolling(taskId);
+                task.onStop?.();
+                break;
+            }
+            case 'exit':
+                task.status = event.data.exitCode === 0 ? 'completed' : 'failed';
+                task.exitCode = event.data.exitCode ?? undefined;
+                task.logs.push(`Process exited with code ${event.data.exitCode}`);
+                this.stopServerPolling(taskId);
+                task.onStop?.();
+                break;
+        }
+    }
+    startServerPolling(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task?.serverSync)
+            return;
+        if (task.serverSync.poller)
+            return;
+        const poll = async () => {
+            const current = this.tasks.get(taskId);
+            if (!current?.serverSync || !current.session)
+                return;
+            try {
+                const events = await (0, index_js_1.fetchSessionMessages)(current.serverSync.sessionId);
+                const startIndex = current.serverSync.lastEventIndex;
+                const newEvents = events.slice(startIndex);
+                current.serverSync.lastEventIndex = events.length;
+                for (const ev of newEvents) {
+                    if (ev.type !== 'message')
+                        continue;
+                    if (ev.message.role !== 'user')
+                        continue;
+                    if (ev.message.id && current.serverSync.seenMessageIds.has(ev.message.id)) {
+                        continue;
+                    }
+                    if (ev.message.id) {
+                        current.serverSync.seenMessageIds.add(ev.message.id);
+                    }
+                    const text = (0, index_js_1.extractTextFromMessage)(ev.message).trim();
+                    if (text === '')
+                        continue;
+                    current.session.emit({
+                        type: 'message',
+                        content: [{ type: 'text', text }],
+                        parentUuid: current.serverSync.lastAssistantMessageId
+                    });
+                }
+            }
+            catch { }
+        };
+        task.serverSync.poller = setInterval(() => {
+            void poll();
+        }, 1000);
+        void poll();
+    }
+    stopServerPolling(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task?.serverSync?.poller) {
+            clearInterval(task.serverSync.poller);
+            task.serverSync.poller = undefined;
+        }
+    }
+    async syncEvent(task, event) {
+        if (!task.serverSync)
+            return;
+        try {
+            await (0, index_js_1.postSessionEvent)(task.serverSync.sessionId, event);
+        }
+        catch (err) {
+            task.logs.push(`Sync event failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    stopTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (task && task.session) {
+            task.session.kill();
+            task.logs.push('Task stopped by user');
+            task.status = 'failed'; // or 'stopped' if we had that status
+            this.stopServerPolling(taskId);
+            if (task.onStop)
+                task.onStop();
+            return true;
+        }
+        return false;
+    }
+}
+exports.taskManager = new TaskManager();

package/dist/apps/cli/src/mcp-tools/types.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface Register {
+    (server: {
+        registerTool: McpServer['registerTool'];
+        registerResource: McpServer['registerResource'];
+        registerPrompt: McpServer['registerPrompt'];
+    }): void;
+}
+export declare const defineRegister: (register: Register) => Register;

package/dist/apps/cli/src/mcp-tools/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineRegister = void 0;
+const defineRegister = (register) => register;
+exports.defineRegister = defineRegister;

package/dist/apps/cli/src/system-prompt.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from '@vibe-forge/core';
+export declare const resolveInjectDefaultSystemPromptValue: (options: {
+    cliValue?: boolean;
+    projectConfig?: Config;
+    userConfig?: Config;
+}) => boolean;
+export declare function loadInjectDefaultSystemPromptValue(cwd: string, cliValue?: boolean): Promise<boolean>;
+export declare const mergeSystemPrompts: (options: {
+    generatedSystemPrompt?: string;
+    userSystemPrompt?: string;
+    injectDefaultSystemPrompt?: boolean;
+}) => string | undefined;

package/dist/apps/cli/src/system-prompt.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 });
+exports.mergeSystemPrompts = exports.resolveInjectDefaultSystemPromptValue = void 0;
+exports.loadInjectDefaultSystemPromptValue = loadInjectDefaultSystemPromptValue;
+const node_process_1 = __importDefault(require("node:process"));
+const core_1 = require("@vibe-forge/core");
+const resolveInjectDefaultSystemPromptValue = (options) => (options.cliValue ??
+    options.userConfig?.conversation?.injectDefaultSystemPrompt ??
+    options.projectConfig?.conversation?.injectDefaultSystemPrompt ??
+    true);
+exports.resolveInjectDefaultSystemPromptValue = resolveInjectDefaultSystemPromptValue;
+async function loadInjectDefaultSystemPromptValue(cwd, cliValue) {
+    if (cliValue != null)
+        return cliValue;
+    const [projectConfig, userConfig] = await (0, core_1.loadConfig)({
+        jsonVariables: {
+            ...node_process_1.default.env,
+            WORKSPACE_FOLDER: cwd,
+            __VF_PROJECT_WORKSPACE_FOLDER__: cwd
+        }
+    });
+    return (0, exports.resolveInjectDefaultSystemPromptValue)({
+        projectConfig,
+        userConfig
+    });
+}
+const mergeSystemPrompts = (options) => {
+    const value = [
+        options.injectDefaultSystemPrompt === false ? undefined : options.generatedSystemPrompt,
+        options.userSystemPrompt
+    ]
+        .filter((part) => typeof part === 'string' && part.trim() !== '')
+        .join('\n\n');
+    return value === '' ? undefined : value;
+};
+exports.mergeSystemPrompts = mergeSystemPrompts;

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

@@ -0,0 +1,3 @@
+export declare function getPackageConfig(key: string, defaultValue?: string): string;
+export declare function getCliVersion(): string;
+export declare function getCliDescription(): string;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageConfig = getPackageConfig;
+exports.getCliVersion = getCliVersion;
+exports.getCliDescription = getCliDescription;
+let packageJson;
+function getPackageJson() {
+    if (!packageJson) {
+        try {
+            // eslint-disable-next-line ts/no-require-imports
+            packageJson = require('@vibe-forge/cli/package.json');
+        }
+        catch {
+            packageJson = {};
+        }
+    }
+    return packageJson;
+}
+function getPackageConfig(key, defaultValue = '') {
+    return getPackageJson()[key] ?? defaultValue;
+}
+function getCliVersion() {
+    return getPackageConfig('version', '0.0.0');
+}
+function getCliDescription() {
+    return getPackageConfig('description', 'Vibe Forge CLI');
+}

package/dist/apps/client/__tests__/api/base.spec.d.ts

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

package/dist/apps/client/__tests__/api/base.spec.js

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ApiError, fetchApiJson, fetchApiJsonOrThrow, getApiErrorMessage } from '#~/api/base';
+vi.mock('#~/runtime-config.js', () => ({
+    getServerHostEnv: () => 'api.example.com',
+    getServerPortEnv: () => '8787'
+}));
+const makeJsonResponse = (body, init) => {
+    return new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+        ...init
+    });
+};
+describe('api base helpers', () => {
+    const fetchMock = vi.fn();
+    beforeEach(() => {
+        fetchMock.mockReset();
+        vi.stubGlobal('fetch', fetchMock);
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+    it('unwraps success envelopes returned by the server', async () => {
+        fetchMock.mockResolvedValue(makeJsonResponse({
+            success: true,
+            data: { sessions: [{ id: 'sess-1' }] }
+        }));
+        await expect(fetchApiJson('/api/sessions')).resolves.toEqual({
+            sessions: [{ id: 'sess-1' }]
+        });
+        expect(fetchMock).toHaveBeenCalledWith('http://api.example.com:8787/api/sessions', undefined);
+    });
+    it('keeps supporting legacy success payloads', async () => {
+        fetchMock.mockResolvedValue(makeJsonResponse({
+            ok: true,
+            removed: false
+        }));
+        await expect(fetchApiJson('/api/automation/rules/rule-1')).resolves.toEqual({
+            ok: true,
+            removed: false
+        });
+    });
+    it('maps api error envelopes to ApiError instances', async () => {
+        fetchMock.mockResolvedValue(makeJsonResponse({
+            success: false,
+            error: {
+                code: 'invalid_payload',
+                message: 'Invalid payload',
+                details: { field: 'prompt' }
+            }
+        }, { status: 400 }));
+        await expect(fetchApiJsonOrThrow('/api/automation/rules', { method: 'POST' }, '[api] create rule failed')).rejects.toMatchObject({
+            name: 'ApiError',
+            status: 400,
+            code: 'invalid_payload',
+            message: 'Invalid payload',
+            details: { field: 'prompt' }
+        });
+        expect(console.error).toHaveBeenCalledWith('[api] create rule failed', 400, 'Invalid payload', { field: 'prompt' });
+    });
+    it('falls back to legacy text errors when the response is not enveloped', async () => {
+        fetchMock.mockResolvedValue(new Response('gateway timeout', { status: 504 }));
+        await expect(fetchApiJson('/api/hooks')).rejects.toEqual(expect.objectContaining({
+            name: 'ApiError',
+            status: 504,
+            code: 'request_failed',
+            message: 'gateway timeout'
+        }));
+    });
+    it('prefers ApiError messages when formatting failures', () => {
+        const error = new ApiError(409, {
+            code: 'rule_disabled',
+            message: 'Rule disabled'
+        });
+        expect(getApiErrorMessage(error, 'unknown')).toBe('Rule disabled');
+        expect(getApiErrorMessage(new Error('boom'), 'unknown')).toBe('boom');
+        expect(getApiErrorMessage({}, 'unknown')).toBe('unknown');
+    });
+});

package/dist/apps/client/__tests__/chat-model-selector.spec.d.ts

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

package/dist/apps/client/__tests__/chat-model-selector.spec.js

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest';
+import { listServiceModels, resolveAdapterForChatModelSelection, resolveAdapterModelCompatibility, resolveChatAdapterSelection, resolveChatModelSelection, resolveDefaultChatModelSelection, resolveModelForChatAdapterSelection, resolveServiceModelSelector } from '#~/hooks/chat/model-selector';
+const modelServices = {
+    serviceA: {
+        apiBaseUrl: 'https://service-a.example.com',
+        apiKey: 'token-a',
+        models: ['modelX', 'modelAOnly']
+    },
+    serviceB: {
+        apiBaseUrl: 'https://service-b.example.com',
+        apiKey: 'token-b',
+        models: ['modelX', 'modelBOnly']
+    }
+};
+const adapterBuiltinModels = {
+    codex: [
+        {
+            value: 'builtin-fast',
+            title: 'builtin-fast',
+            description: 'Fast builtin model'
+        }
+    ],
+    'claude-code': [
+        {
+            value: 'sonnet',
+            title: 'sonnet',
+            description: 'Claude Sonnet'
+        }
+    ]
+};
+const modelMetadata = {
+    serviceA: {
+        defaultAdapter: 'claude-code'
+    },
+    'serviceA,modelX': {
+        defaultAdapter: 'codex'
+    }
+};
+describe('chat model selector helpers', () => {
+    it('keeps duplicate model names unique by selector value', () => {
+        const serviceModels = listServiceModels(modelServices);
+        const selectors = serviceModels
+            .filter(entry => entry.model === 'modelX')
+            .map(entry => entry.selectorValue);
+        expect(selectors).toEqual(['serviceA,modelX', 'serviceB,modelX']);
+        expect(new Set(selectors).size).toBe(2);
+    });
+    it('honors a configured default model that is already service-qualified', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultChatModelSelection({
+            defaultModel: 'serviceA,modelX',
+            defaultModelService: 'serviceB',
+            serviceModels
+        })).toBe('serviceA,modelX');
+    });
+    it('resolves a raw default model through the configured default service first', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultChatModelSelection({
+            defaultModel: 'modelX',
+            defaultModelService: 'serviceB',
+            serviceModels
+        })).toBe('serviceB,modelX');
+    });
+    it('upgrades legacy raw persisted values to the canonical selector', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveChatModelSelection({
+            value: 'modelX',
+            defaultModelService: 'serviceB',
+            serviceModels
+        })).toBe('serviceB,modelX');
+    });
+    it('keeps builtin adapter models unprefixed', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveChatModelSelection({
+            value: 'builtin-fast',
+            builtinModels: ['builtin-fast'],
+            defaultModelService: 'serviceA',
+            serviceModels
+        })).toBe('builtin-fast');
+    });
+    it('routes duplicate-name models through the selected service when already canonical', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveChatModelSelection({
+            value: 'serviceB,modelX',
+            defaultModelService: 'serviceA',
+            serviceModels
+        })).toBe('serviceB,modelX');
+    });
+    it('uses the default service first model before builtin fallback when only defaultModelService is configured', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveDefaultChatModelSelection({
+            defaultModelService: 'serviceB',
+            builtinModels: ['builtin-fast'],
+            serviceModels
+        })).toBe('serviceB,modelX');
+    });
+    it('falls back to the first matching service when no default service is provided', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveServiceModelSelector({
+            value: 'modelX',
+            serviceModels
+        })).toBe('serviceA,modelX');
+    });
+    it('resolves adapter by exact model selector metadata before service metadata', () => {
+        expect(resolveAdapterForChatModelSelection({
+            model: 'serviceA,modelX',
+            availableAdapters: ['claude-code', 'codex'],
+            defaultAdapter: 'claude-code',
+            adapterBuiltinModels,
+            modelMetadata
+        })).toBe('codex');
+        expect(resolveAdapterForChatModelSelection({
+            model: 'serviceA,modelAOnly',
+            availableAdapters: ['claude-code', 'codex'],
+            defaultAdapter: 'codex',
+            adapterBuiltinModels,
+            modelMetadata
+        })).toBe('claude-code');
+    });
+    it('falls back to a builtin-compatible adapter when no routed selector metadata exists', () => {
+        expect(resolveAdapterForChatModelSelection({
+            model: 'sonnet',
+            availableAdapters: ['codex', 'claude-code'],
+            defaultAdapter: 'codex',
+            adapterBuiltinModels,
+            modelMetadata: {}
+        })).toBe('claude-code');
+    });
+    it('uses adapter-level default model before global defaults', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveModelForChatAdapterSelection({
+            adapter: 'codex',
+            adapters: {
+                codex: {
+                    defaultModel: 'serviceB,modelBOnly'
+                }
+            },
+            defaultModel: 'serviceA,modelAOnly',
+            defaultModelService: 'serviceA',
+            builtinModels: ['builtin-fast'],
+            fallbackBuiltinModels: ['builtin-fast', 'sonnet'],
+            serviceModels
+        })).toBe('serviceB,modelBOnly');
+    });
+    it('switches to adapter defaultModel when includeModels excludes the current service', () => {
+        const serviceModels = listServiceModels(modelServices);
+        expect(resolveAdapterModelCompatibility({
+            adapter: 'codex',
+            model: 'serviceB,modelBOnly',
+            adapterConfig: {
+                defaultModel: 'serviceA,modelAOnly',
+                includeModels: ['serviceA']
+            },
+            serviceModels,
+            preferredServiceKey: 'serviceA',
+            preserveUnknownDefaultModel: false
+        })).toMatchObject({
+            model: 'serviceA,modelAOnly',
+            warning: {
+                adapter: 'codex',
+                requestedModel: 'serviceB,modelBOnly',
+                resolvedModel: 'serviceA,modelAOnly',
+                reason: 'not_included'
+            }
+        });
+    });
+    it('validates adapter selections against the available adapter list', () => {
+        expect(resolveChatAdapterSelection({
+            value: 'missing',
+            availableAdapters: ['codex', 'claude-code'],
+            defaultAdapter: 'claude-code'
+        })).toBe('claude-code');
+    });
+});

package/dist/apps/client/__tests__/sessionTimelineMermaid.spec.d.ts

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