@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/hooks/src/type.d.ts

@@ -0,0 +1,148 @@
+import type { TaskRuntime } from '@vibe-forge/types';
+export type HookSource = 'native' | 'bridge';
+export interface HookToolCall {
+    toolCallId?: string;
+    toolName: string;
+    toolInput?: unknown;
+}
+export interface HookToolResult extends HookToolCall {
+    toolResponse?: unknown;
+    isError?: boolean;
+}
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
+ */
+export interface HookInputCore {
+    cwd: string;
+    sessionId: string;
+    hookEventName: keyof HookInputs;
+    transcriptPath?: string | null;
+    turnId?: string;
+    adapter?: string;
+    runtime?: TaskRuntime;
+    hookSource?: HookSource;
+    canBlock?: boolean;
+}
+export interface HookInputs {
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-input
+     */
+    PreToolUse: HookInputCore & HookToolCall;
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-input
+     */
+    PostToolUse: HookInputCore & HookToolResult;
+    Notification: HookInputCore;
+    UserPromptSubmit: HookInputCore & {
+        prompt: string;
+    };
+    Stop: HookInputCore & {
+        stopHookActive?: boolean;
+        lastAssistantMessage?: string;
+    };
+    SubagentStop: HookInputCore;
+    PreCompact: HookInputCore;
+    SessionStart: HookInputCore & {
+        source?: 'startup' | 'resume';
+        model?: string;
+    };
+    SessionEnd: HookInputCore & {
+        reason: string;
+        exitCode?: number;
+        stderr?: string;
+        lastAssistantMessage?: string;
+    };
+    StartTasks: HookInputCore & {
+        tasks: Array<{
+            description: string;
+            type: 'default' | 'spec' | 'entity';
+            name?: string;
+            adapter?: string;
+            background?: boolean;
+        }>;
+    };
+    GenerateSystemPrompt: HookInputCore & {
+        type?: 'spec' | 'entity';
+        name?: string;
+        data?: unknown;
+    };
+    TaskStart: HookInputCore & {
+        adapter?: string;
+        options: unknown;
+        adapterOptions: unknown;
+    };
+    TaskStop: HookInputCore & {
+        exitCode?: number;
+        stderr?: string;
+        adapter?: string;
+        options: unknown;
+        adapterOptions: unknown;
+    };
+}
+export type HookInput = HookInputs[keyof HookInputs];
+/**
+ * https://docs.anthropic.com/en/docs/claude-code/hooks#common-json-fields
+ */
+export interface HookOutputCore {
+    /**
+     * Whether Claude should continue after hook execution
+     * @default true
+     */
+    continue?: boolean;
+    /**
+     * Message shown when continue is false
+     */
+    stopReason?: string;
+    /**
+     * Hide stdout from transcript mode
+     * @default false
+     */
+    suppressOutput?: boolean;
+    /**
+     * Optional warning message shown to the user
+     */
+    systemMessage?: string;
+}
+export interface HookOutputs {
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-decision-control
+     */
+    PreToolUse: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'PreToolUse';
+            permissionDecision: 'allow' | 'deny' | 'ask';
+            permissionDecisionReason: string;
+        };
+    };
+    /**
+     * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-decision-control
+     */
+    PostToolUse: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'PostToolUse';
+            additionalContext: string;
+        };
+    };
+    Notification: HookOutputCore;
+    Stop: HookOutputCore;
+    SessionStart: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'SessionStart';
+            additionalContext: string;
+        };
+    };
+    SessionEnd: HookOutputCore;
+    SubagentStop: HookOutputCore;
+    PreCompact: HookOutputCore;
+    UserPromptSubmit: HookOutputCore & {
+        hookSpecificOutput?: {
+            hookEventName: 'UserPromptSubmit';
+            additionalContext: string;
+        };
+    };
+    StartTasks: HookOutputCore;
+    GenerateSystemPrompt: HookOutputCore;
+    TaskStart: HookOutputCore;
+    TaskStop: HookOutputCore;
+}
+export type HookOutput = HookOutputs[keyof HookOutputs];

package/dist/packages/hooks/src/type.js

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

package/dist/packages/mcp/__tests__/bindings.spec.d.ts

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

package/dist/packages/mcp/__tests__/bindings.spec.js

@@ -0,0 +1,50 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => {
+    const taskBindings = {
+        createTaskId: vi.fn(),
+        callHook: vi.fn(),
+        generateAdapterQueryOptions: vi.fn(),
+        run: vi.fn(),
+        loadInjectDefaultSystemPromptValue: vi.fn(),
+        mergeSystemPrompts: vi.fn(),
+        extractTextFromMessage: vi.fn()
+    };
+    return {
+        taskBindings,
+        createMcpTaskBindings: vi.fn(() => taskBindings),
+        getParentSessionId: vi.fn(),
+        createChildSession: vi.fn(),
+        postSessionEvent: vi.fn(),
+        fetchSessionMessages: vi.fn(),
+        extractTextFromMessage: vi.fn()
+    };
+});
+vi.mock('#~/task-bindings.js', () => ({
+    createMcpTaskBindings: mocks.createMcpTaskBindings
+}));
+vi.mock('#~/sync.js', () => ({
+    getParentSessionId: mocks.getParentSessionId,
+    createChildSession: mocks.createChildSession,
+    postSessionEvent: mocks.postSessionEvent,
+    fetchSessionMessages: mocks.fetchSessionMessages,
+    extractTextFromMessage: mocks.extractTextFromMessage
+}));
+describe('mcp bindings', () => {
+    afterEach(() => {
+        vi.resetModules();
+        vi.clearAllMocks();
+    });
+    it('uses local task bindings by default', async () => {
+        const { resolveDefaultMcpBindings } = await import('#~/bindings.js');
+        const bindings = resolveDefaultMcpBindings('test');
+        expect(mocks.createMcpTaskBindings).toHaveBeenCalledTimes(1);
+        expect(bindings.task).toBe(mocks.taskBindings);
+        expect(bindings.sync.extractTextFromMessage).toBe(mocks.taskBindings.extractTextFromMessage);
+    });
+    it('keeps sync message extraction when task bindings are omitted explicitly', async () => {
+        const { createMcpBindings } = await import('#~/bindings.js');
+        const bindings = createMcpBindings('test');
+        expect(bindings.task).toBeUndefined();
+        expect(bindings.sync.extractTextFromMessage).toBe(mocks.extractTextFromMessage);
+    });
+});

package/dist/packages/mcp/__tests__/mcp-test-utils.d.ts

@@ -0,0 +1,32 @@
+import type { z } from 'zod';
+type ToolHandler = (args: any) => Promise<any>;
+interface ToolEntry {
+    handler: ToolHandler;
+    schema: z.ZodType<any>;
+    title: string;
+    description?: string;
+}
+/**
+ * Creates a tool tester that can register and call tools, simulating the MCP server environment.
+ */
+export declare function createToolTester(): {
+    mockRegister: {
+        registerTool: import("@modelcontextprotocol/sdk/server/mcp.js").McpServer["registerTool"];
+        registerResource: import("@modelcontextprotocol/sdk/server/mcp.js").McpServer["registerResource"];
+        registerPrompt: import("@modelcontextprotocol/sdk/server/mcp.js").McpServer["registerPrompt"];
+    };
+    /**
+     * Calls a registered tool with the given arguments.
+     * Performs Zod validation before calling the handler.
+     */
+    callTool(name: string, args: unknown): Promise<any>;
+    /**
+     * Gets information about a registered tool.
+     */
+    getToolInfo(name: string): ToolEntry | undefined;
+    /**
+     * Returns a list of all registered tool names.
+     */
+    getRegisteredTools(): string[];
+};
+export {};

package/dist/packages/mcp/__tests__/mcp-test-utils.js

@@ -0,0 +1,60 @@
+/**
+ * Creates a tool tester that can register and call tools, simulating the MCP server environment.
+ */
+export function createToolTester() {
+    const tools = new Map();
+    const mockRegister = {
+        registerTool: (name, options, handler) => {
+            tools.set(name, {
+                // @ts-ignore - The handler type from the SDK is complex with extra context
+                handler: handler,
+                schema: options.inputSchema,
+                title: options.title,
+                description: options.description
+            });
+            return {
+                disable: () => {
+                    // In a real server this would disable the tool
+                }
+            };
+        },
+        registerPrompt: () => {
+            return {
+                disable: () => { }
+            };
+        },
+        registerResource: () => {
+            return {
+                disable: () => { }
+            };
+        }
+    };
+    return {
+        mockRegister,
+        /**
+         * Calls a registered tool with the given arguments.
+         * Performs Zod validation before calling the handler.
+         */
+        async callTool(name, args) {
+            const tool = tools.get(name);
+            if (!tool) {
+                throw new Error(`Tool "${name}" not found. Registered tools: ${Array.from(tools.keys()).join(', ')}`);
+            }
+            // Simulate Zod validation that McpServer would do
+            const validatedArgs = tool.schema.parse(args);
+            return tool.handler(validatedArgs);
+        },
+        /**
+         * Gets information about a registered tool.
+         */
+        getToolInfo(name) {
+            return tools.get(name);
+        },
+        /**
+         * Returns a list of all registered tool names.
+         */
+        getRegisteredTools() {
+            return Array.from(tools.keys());
+        }
+    };
+}

package/dist/packages/mcp/__tests__/proxy.spec.d.ts

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

package/dist/packages/mcp/__tests__/proxy.spec.js

@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createFilteredRegister, shouldEnableCategory } from '#~/tools/proxy.js';
+describe('proxy logic', () => {
+    describe('shouldEnableCategory', () => {
+        it('should enable when no filters', () => {
+            expect(shouldEnableCategory('cat1', {})).toBe(true);
+        });
+        it('should respect include', () => {
+            expect(shouldEnableCategory('cat1', { include: ['cat1'] })).toBe(true);
+            expect(shouldEnableCategory('cat2', { include: ['cat1'] })).toBe(false);
+        });
+        it('should respect exclude', () => {
+            expect(shouldEnableCategory('cat1', { exclude: ['cat1'] })).toBe(false);
+            expect(shouldEnableCategory('cat2', { exclude: ['cat1'] })).toBe(true);
+        });
+        it('should prioritize include then exclude', () => {
+            expect(shouldEnableCategory('cat1', { include: ['cat1'], exclude: ['cat1'] })).toBe(false);
+            expect(shouldEnableCategory('cat1', { include: ['cat1'], exclude: ['cat2'] })).toBe(true);
+        });
+    });
+    describe('createFilteredRegister', () => {
+        const mockTool = { disable: vi.fn() };
+        const mockPrompt = { disable: vi.fn() };
+        const mockResource = { disable: vi.fn() };
+        const mockServer = {
+            registerTool: vi.fn().mockReturnValue(mockTool),
+            registerPrompt: vi.fn().mockReturnValue(mockPrompt),
+            registerResource: vi.fn().mockReturnValue(mockResource)
+        };
+        it('should disable tool if not included', () => {
+            const proxy = createFilteredRegister(mockServer, {
+                tools: { include: ['tool1'] }
+            });
+            proxy.registerTool('tool2', { description: 'test' }, async () => ({ content: [] }));
+            expect(mockTool.disable).toHaveBeenCalled();
+        });
+        it('should NOT disable tool if included', () => {
+            const proxy = createFilteredRegister(mockServer, {
+                tools: { include: ['tool1'] }
+            });
+            vi.clearAllMocks();
+            proxy.registerTool('tool1', { description: 'test' }, async () => ({ content: [] }));
+            expect(mockTool.disable).not.toHaveBeenCalled();
+        });
+        it('should disable tool if excluded', () => {
+            const proxy = createFilteredRegister(mockServer, {
+                tools: { exclude: ['tool1'] }
+            });
+            vi.clearAllMocks();
+            proxy.registerTool('tool1', { description: 'test' }, async () => ({ content: [] }));
+            expect(mockTool.disable).toHaveBeenCalled();
+        });
+    });
+});

package/dist/packages/mcp/__tests__/task-bindings.spec.d.ts

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

package/dist/packages/mcp/__tests__/task-bindings.spec.js

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    callHook: vi.fn(),
+    generateAdapterQueryOptions: vi.fn(),
+    run: vi.fn(),
+    extractTextFromMessage: vi.fn(),
+    loadInjectDefaultSystemPromptValue: vi.fn(),
+    mergeSystemPrompts: vi.fn(),
+    uuid: vi.fn()
+}));
+vi.mock('@vibe-forge/hooks', () => ({
+    callHook: mocks.callHook
+}));
+vi.mock('@vibe-forge/task', () => ({
+    generateAdapterQueryOptions: mocks.generateAdapterQueryOptions,
+    run: mocks.run
+}));
+vi.mock('@vibe-forge/config', () => ({
+    loadInjectDefaultSystemPromptValue: mocks.loadInjectDefaultSystemPromptValue,
+    mergeSystemPrompts: mocks.mergeSystemPrompts
+}));
+vi.mock('@vibe-forge/utils/chat-message', () => ({
+    extractTextFromMessage: mocks.extractTextFromMessage
+}));
+vi.mock('@vibe-forge/utils/uuid', () => ({
+    uuid: mocks.uuid
+}));
+describe('createMcpTaskBindings', () => {
+    it('composes task bindings from mcp-owned dependencies', async () => {
+        const { createMcpTaskBindings } = await import('#~/task-bindings.js');
+        const bindings = createMcpTaskBindings();
+        expect(bindings.createTaskId).toBe(mocks.uuid);
+        expect(bindings.callHook).toBe(mocks.callHook);
+        expect(bindings.generateAdapterQueryOptions).toBe(mocks.generateAdapterQueryOptions);
+        expect(bindings.run).toBe(mocks.run);
+        expect(bindings.extractTextFromMessage).toBe(mocks.extractTextFromMessage);
+        expect(bindings.loadInjectDefaultSystemPromptValue).toBe(mocks.loadInjectDefaultSystemPromptValue);
+        expect(bindings.mergeSystemPrompts).toBe(mocks.mergeSystemPrompts);
+    });
+});

package/dist/packages/mcp/__tests__/task-manager.spec.d.ts

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

package/dist/packages/mcp/__tests__/task-manager.spec.js

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    run: vi.fn(),
+    generateAdapterQueryOptions: vi.fn(),
+    callHook: vi.fn(),
+    loadInjectDefaultSystemPromptValue: vi.fn(),
+    mergeSystemPrompts: vi.fn(),
+    extractTextFromMessage: vi.fn(),
+    postSessionEvent: vi.fn(),
+    fetchSessionMessages: vi.fn()
+}));
+vi.mock('@vibe-forge/task', () => ({
+    run: mocks.run,
+    generateAdapterQueryOptions: mocks.generateAdapterQueryOptions
+}));
+vi.mock('@vibe-forge/hooks', () => ({
+    callHook: mocks.callHook
+}));
+vi.mock('@vibe-forge/config', () => ({
+    loadInjectDefaultSystemPromptValue: mocks.loadInjectDefaultSystemPromptValue,
+    mergeSystemPrompts: mocks.mergeSystemPrompts
+}));
+vi.mock('@vibe-forge/utils/chat-message', () => ({
+    extractTextFromMessage: mocks.extractTextFromMessage
+}));
+vi.mock('#~/sync.js', () => ({
+    postSessionEvent: mocks.postSessionEvent,
+    fetchSessionMessages: mocks.fetchSessionMessages
+}));
+describe('taskManager fatal error scenarios', () => {
+    beforeEach(() => {
+        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('');
+    });
+    it('keeps the task failed when a fatal error is followed by stop', async () => {
+        const { TaskManager } = await import('#~/tools/task/manager.js');
+        mocks.run.mockImplementationOnce(async (_options, adapterOptions) => {
+            const session = {
+                emit: vi.fn(() => {
+                    adapterOptions.onEvent({
+                        type: 'error',
+                        data: {
+                            message: 'Incomplete response returned',
+                            fatal: true
+                        }
+                    });
+                    adapterOptions.onEvent({
+                        type: 'stop',
+                        data: undefined
+                    });
+                }),
+                kill: vi.fn()
+            };
+            return { session };
+        });
+        const managedTaskManager = new TaskManager();
+        await managedTaskManager.startTask({
+            taskId: 'task-fatal-stop',
+            description: 'trigger',
+            background: false
+        });
+        const task = managedTaskManager.getTask('task-fatal-stop');
+        expect(task?.status).toBe('failed');
+        expect(task?.logs).toContain('Incomplete response returned');
+    });
+});

package/dist/packages/mcp/__tests__/tools.spec.d.ts

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

package/dist/packages/mcp/__tests__/tools.spec.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { createMcpTools } from '#~/tools/index.js';
+import wait from '#~/tools/general/wait.js';
+import { createToolTester } from './mcp-test-utils.js';
+describe('mcp tools integration', () => {
+    it('registers task tools by default', () => {
+        expect(createMcpTools()).toHaveProperty('task');
+    });
+    describe('wait tool', () => {
+        it('should register wait tool', () => {
+            const tester = createToolTester();
+            wait(tester.mockRegister);
+            expect(tester.getRegisteredTools()).toContain('wait');
+            const info = tester.getToolInfo('wait');
+            expect(info?.title).toBe('Wait Tool');
+        });
+        it('should wait for specified time', async () => {
+            const tester = createToolTester();
+            wait(tester.mockRegister);
+            const start = Date.now();
+            const ms = 100;
+            const result = await tester.callTool('wait', { ms });
+            const duration = Date.now() - start;
+            expect(duration).toBeGreaterThanOrEqual(ms - 10); // Allow some jitter
+            expect(result.content[0].text).toBe(`Finished waiting for ${ms}ms`);
+        });
+        it('should fail validation with out-of-range input', async () => {
+            const tester = createToolTester();
+            wait(tester.mockRegister);
+            // Max is 60000ms
+            await expect(tester.callTool('wait', { ms: 70000 }))
+                .rejects.toThrow();
+            // Min is 0ms
+            await expect(tester.callTool('wait', { ms: -1 }))
+                .rejects.toThrow();
+        });
+    });
+});

package/dist/packages/mcp/src/bindings.d.ts

@@ -0,0 +1,5 @@
+import type { McpBindings, McpTaskBindings } from './types';
+export declare const createMcpBindings: (version: string, options?: {
+    task?: McpTaskBindings;
+}) => McpBindings;
+export declare const resolveDefaultMcpBindings: (version: string) => McpBindings;

package/dist/packages/mcp/src/bindings.js

@@ -0,0 +1,16 @@
+import { createMcpTaskBindings as createDefaultMcpTaskBindings } from './task-bindings';
+import { createChildSession, extractTextFromMessage, fetchSessionMessages, getParentSessionId, postSessionEvent } from './sync';
+export const createMcpBindings = (version, options = {}) => ({
+    version,
+    task: options.task,
+    sync: {
+        getParentSessionId,
+        createChildSession,
+        postSessionEvent,
+        fetchSessionMessages,
+        extractTextFromMessage: options.task?.extractTextFromMessage ?? extractTextFromMessage
+    }
+});
+export const resolveDefaultMcpBindings = (version) => (createMcpBindings(version, {
+    task: createDefaultMcpTaskBindings()
+}));

package/dist/packages/mcp/src/cli.d.ts

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

package/dist/packages/mcp/src/cli.js

@@ -0,0 +1,10 @@
+import { program } from 'commander';
+import { configureMcpCommand } from './command';
+import { getMcpDescription, getMcpVersion } from './package-config';
+const version = getMcpVersion();
+program
+    .name('vf-mcp')
+    .description(getMcpDescription())
+    .version(version);
+configureMcpCommand(program, version);
+void program.parseAsync();

package/dist/packages/mcp/src/command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare const configureMcpCommand: (command: Command, version: string) => Command;
+export declare function registerMcpCommand(program: Command, version: string): Command;

package/dist/packages/mcp/src/command.js

@@ -0,0 +1,47 @@
+import process from 'node:process';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMcpTools } from './tools';
+import { createFilteredRegister, shouldEnableCategory } from './tools/proxy';
+export const configureMcpCommand = (command, version) => (command
+    .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 tools = createMcpTools();
+    const server = new McpServer({
+        name: 'vibe-forge',
+        version
+    });
+    const proxyServer = 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 = process.env.__VF_PROJECT_AI_RUN_TYPE__ ?? 'cli';
+    Object.entries(tools).forEach(([category, register]) => {
+        if (category === 'interaction' && runType !== 'server') {
+            return;
+        }
+        if (shouldEnableCategory(category, categoryFilter)) {
+            register(proxyServer);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('MCP server started on stdio');
+}));
+export function registerMcpCommand(program, version) {
+    return configureMcpCommand(program.command('mcp'), version);
+}

package/dist/packages/mcp/src/index.d.ts

@@ -0,0 +1,2 @@
+export { configureMcpCommand, registerMcpCommand } from './command';
+export type { McpManagedTaskInput, McpOptions, McpResolvedTaskQueryOptions, McpSelectionFilter, McpTaskBindings, McpTaskDefinitionType, McpTaskHookInputs, McpTaskOutputEvent, McpTaskQueryOptions, McpTaskRunOptions, McpTaskSession } from './types';

package/dist/packages/mcp/src/index.js

@@ -0,0 +1 @@
+export { configureMcpCommand, registerMcpCommand } from './command';

package/dist/packages/mcp/src/package-config.d.ts

@@ -0,0 +1,3 @@
+export declare const getPackageConfig: (key: string, defaultValue?: string) => string;
+export declare const getMcpVersion: () => string;
+export declare const getMcpDescription: () => string;

package/dist/packages/mcp/src/package-config.js

@@ -0,0 +1,19 @@
+let packageJson;
+const getPackageJson = () => {
+    if (!packageJson) {
+        try {
+            // eslint-disable-next-line ts/no-require-imports
+            packageJson = require('@vibe-forge/mcp/package.json');
+        }
+        catch {
+            packageJson = {};
+        }
+    }
+    return packageJson;
+};
+export const getPackageConfig = (key, defaultValue = '') => {
+    const value = getPackageJson()[key];
+    return typeof value === 'string' ? value : defaultValue;
+};
+export const getMcpVersion = () => getPackageConfig('version', '0.0.0');
+export const getMcpDescription = () => getPackageConfig('description', 'Vibe Forge MCP');

package/dist/packages/mcp/src/sync.d.ts

@@ -0,0 +1,11 @@
+import type { WSEvent } from '@vibe-forge/types';
+import { extractTextFromMessage } from '@vibe-forge/utils/chat-message';
+export declare const getParentSessionId: () => string | undefined;
+export declare const createChildSession: (params: {
+    id: string;
+    title?: string;
+    parentSessionId?: string;
+}) => Promise<any>;
+export declare const postSessionEvent: (sessionId: string, payload: Record<string, unknown>) => Promise<void>;
+export declare const fetchSessionMessages: (sessionId: string) => Promise<WSEvent[]>;
+export { extractTextFromMessage };