@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/adapters/codex/src/schema.d.ts

@@ -0,0 +1,97 @@
+export interface CodexBashToolInput {
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+}
+export interface CodexReadFileToolInput {
+    path: string;
+    startLine?: number;
+    endLine?: number;
+}
+export interface CodexWriteFileToolInput {
+    path: string;
+    content: string;
+}
+export interface CodexEditFileToolInput {
+    path: string;
+    oldString: string;
+    newString: string;
+}
+export interface CodexGlobToolInput {
+    pattern: string;
+    cwd?: string;
+}
+export interface CodexGrepToolInput {
+    pattern: string;
+    path?: string;
+    glob?: string;
+    ignoreCase?: boolean;
+    contextLines?: number;
+}
+export interface CodexListDirToolInput {
+    path: string;
+}
+export interface CodexWebSearchToolInput {
+    query: string;
+}
+export interface CodexWebFetchToolInput {
+    url: string;
+}
+export interface CodexApplyPatchToolInput {
+    patch: string;
+    cwd?: string;
+}
+export interface CodexBashToolOutput {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CodexReadFileToolOutput {
+    content: string;
+}
+export interface CodexGlobToolOutput {
+    files: string[];
+}
+export interface CodexGrepToolOutput {
+    matches: Array<{
+        file: string;
+        line: number;
+        text: string;
+    }>;
+}
+export interface CodexListDirToolOutput {
+    entries: Array<{
+        name: string;
+        type: 'file' | 'directory';
+        size?: number;
+    }>;
+}
+export interface CodexWebSearchToolOutput {
+    results: Array<{
+        title: string;
+        url: string;
+        snippet: string;
+    }>;
+}
+declare module '@vibe-forge/core' {
+    interface ToolInputs {
+        'adapter:codex:Bash': CodexBashToolInput;
+        'adapter:codex:ReadFile': CodexReadFileToolInput;
+        'adapter:codex:WriteFile': CodexWriteFileToolInput;
+        'adapter:codex:EditFile': CodexEditFileToolInput;
+        'adapter:codex:Glob': CodexGlobToolInput;
+        'adapter:codex:Grep': CodexGrepToolInput;
+        'adapter:codex:ListDir': CodexListDirToolInput;
+        'adapter:codex:WebSearch': CodexWebSearchToolInput;
+        'adapter:codex:WebFetch': CodexWebFetchToolInput;
+        'adapter:codex:ApplyPatch': CodexApplyPatchToolInput;
+    }
+    interface ToolOutputs {
+        'adapter:codex:Bash': CodexBashToolOutput;
+        'adapter:codex:ReadFile': CodexReadFileToolOutput;
+        'adapter:codex:Glob': CodexGlobToolOutput;
+        'adapter:codex:Grep': CodexGrepToolOutput;
+        'adapter:codex:ListDir': CodexListDirToolOutput;
+        'adapter:codex:WebSearch': CodexWebSearchToolOutput;
+    }
+}

package/dist/packages/adapters/codex/src/schema.js

@@ -0,0 +1,4 @@
+// Codex tool input/output schemas
+// Augments @vibe-forge/core ToolInputs / ToolOutputs so Codex tools are
+// available across the platform with their codex-specific names.
+export {};

package/dist/packages/adapters/codex/src/types.d.ts

@@ -0,0 +1,266 @@
+export interface CodexRequest {
+    method: string;
+    id: number;
+    params?: Record<string, unknown>;
+}
+export interface CodexNotification {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface CodexResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export type CodexThreadStatus = {
+    type: 'notLoaded';
+} | {
+    type: 'idle';
+} | {
+    type: 'systemError';
+} | {
+    type: 'active';
+    activeFlags?: string[];
+};
+export interface CodexThread {
+    id: string;
+    name?: string | null;
+    preview?: string;
+    ephemeral?: boolean;
+    modelProvider?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    status?: CodexThreadStatus;
+}
+export type CodexTurnStatus = 'inProgress' | 'completed' | 'interrupted' | 'failed';
+export interface CodexTurn {
+    id: string;
+    status: CodexTurnStatus;
+    items: CodexThreadItem[];
+    error?: {
+        message: string;
+        codexErrorInfo?: string;
+        additionalDetails?: string;
+    } | null;
+}
+export interface CodexItemUserMessage {
+    type: 'userMessage';
+    id: string;
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image';
+        url: string;
+    }>;
+}
+export interface CodexItemAgentMessage {
+    type: 'agentMessage';
+    id: string;
+    text: string;
+    phase?: 'commentary' | 'final_answer';
+}
+export interface CodexItemPlan {
+    type: 'plan';
+    id: string;
+    text: string;
+}
+export interface CodexItemReasoning {
+    type: 'reasoning';
+    id: string;
+    summary: string;
+    content?: string;
+}
+export interface CodexCommandAction {
+    type: string;
+    path?: string;
+    content?: string;
+}
+export interface CodexItemCommandExecution {
+    type: 'commandExecution';
+    id: string;
+    command: string[];
+    cwd?: string;
+    status: 'inProgress' | 'completed' | 'failed' | 'declined';
+    commandActions?: CodexCommandAction[];
+    aggregatedOutput?: string;
+    exitCode?: number;
+    durationMs?: number;
+}
+export interface CodexFileChange {
+    path: string;
+    kind: 'add' | 'edit' | 'delete' | 'rename';
+    diff?: string;
+}
+export interface CodexItemFileChange {
+    type: 'fileChange';
+    id: string;
+    changes: CodexFileChange[];
+    status: 'inProgress' | 'completed' | 'failed' | 'declined';
+}
+export interface CodexItemMcpToolCall {
+    type: 'mcpToolCall';
+    id: string;
+    server: string;
+    tool: string;
+    status: 'inProgress' | 'completed' | 'failed';
+    arguments?: Record<string, unknown>;
+    result?: unknown;
+    error?: unknown;
+}
+export interface CodexItemDynamicToolCall {
+    type: 'dynamicToolCall';
+    id: string;
+    tool: string;
+    arguments?: Record<string, unknown>;
+    status: 'inProgress' | 'completed' | 'failed';
+    contentItems?: unknown[];
+    success?: boolean;
+    durationMs?: number;
+}
+export interface CodexItemWebSearch {
+    type: 'webSearch';
+    id: string;
+    query: string;
+    action?: {
+        type: 'search' | 'openPage' | 'findInPage';
+        url?: string;
+        query?: string;
+        pattern?: string;
+    };
+}
+export interface CodexItemEnteredReviewMode {
+    type: 'enteredReviewMode';
+    id: string;
+    review: string;
+}
+export interface CodexItemExitedReviewMode {
+    type: 'exitedReviewMode';
+    id: string;
+    review: string;
+}
+export interface CodexItemContextCompaction {
+    type: 'contextCompaction';
+    id: string;
+}
+export type CodexThreadItem = CodexItemUserMessage | CodexItemAgentMessage | CodexItemPlan | CodexItemReasoning | CodexItemCommandExecution | CodexItemFileChange | CodexItemMcpToolCall | CodexItemDynamicToolCall | CodexItemWebSearch | CodexItemEnteredReviewMode | CodexItemExitedReviewMode | CodexItemContextCompaction;
+export interface TurnStartedParams {
+    turn: CodexTurn;
+}
+export interface TurnCompletedParams {
+    turn: CodexTurn;
+}
+export interface TurnDiffUpdatedParams {
+    threadId: string;
+    turnId: string;
+    diff: string;
+}
+export interface TurnPlanUpdatedParams {
+    turnId: string;
+    explanation?: string;
+    plan: Array<{
+        step: string;
+        status: 'pending' | 'inProgress' | 'completed';
+    }>;
+}
+export interface ItemStartedParams {
+    item: CodexThreadItem;
+}
+export interface ItemCompletedParams {
+    item: CodexThreadItem;
+}
+export interface ItemAgentMessageDeltaParams {
+    itemId: string;
+    delta: string;
+}
+export interface ItemCommandExecutionOutputDeltaParams {
+    itemId: string;
+    delta: string;
+    stream?: 'stdout' | 'stderr';
+}
+export interface ItemPlanDeltaParams {
+    itemId: string;
+    delta: string;
+}
+export interface ItemReasoningDeltaParams {
+    itemId: string;
+    delta: string;
+    summaryIndex?: number;
+}
+export interface CommandExecApprovalParams {
+    itemId: string;
+    threadId: string;
+    turnId: string;
+    reason?: string;
+    command?: string[];
+    cwd?: string;
+    commandActions?: CodexCommandAction[];
+    proposedExecpolicyAmendment?: unknown;
+    networkApprovalContext?: {
+        host: string;
+        protocol?: string;
+        port?: number;
+    };
+    availableDecisions?: string[];
+}
+export interface FileChangeApprovalParams {
+    itemId: string;
+    threadId: string;
+    turnId: string;
+    reason?: string;
+    grantRoot?: string;
+}
+export type CommandExecDecision = 'accept' | 'acceptForSession' | 'decline' | 'cancel' | {
+    acceptWithExecpolicyAmendment: {
+        execpolicy_amendment: string[];
+    };
+};
+export type FileChangeDecision = 'accept' | 'acceptForSession' | 'decline' | 'cancel';
+export type CodexInputItem = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    url: string;
+} | {
+    type: 'localImage';
+    path: string;
+} | {
+    type: 'skill';
+    name: string;
+    path: string;
+} | {
+    type: 'mention';
+    name: string;
+    path: string;
+};
+export type CodexSandboxPolicy = {
+    type: 'readOnly';
+    access?: {
+        type: 'fullAccess';
+    } | {
+        type: 'restricted';
+        includePlatformDefaults?: boolean;
+        readableRoots?: string[];
+    };
+} | {
+    type: 'workspaceWrite';
+    writableRoots?: string[];
+    networkAccess?: boolean;
+    readOnlyAccess?: {
+        type: 'fullAccess';
+    } | {
+        type: 'restricted';
+        includePlatformDefaults?: boolean;
+        readableRoots?: string[];
+    };
+} | {
+    type: 'dangerFullAccess';
+} | {
+    type: 'externalSandbox';
+    networkAccess?: 'restricted' | 'enabled';
+};

package/dist/packages/adapters/codex/src/types.js

@@ -0,0 +1,2 @@
+// ─── JSON-RPC 2.0 base shapes ────────────────────────────────────────────────
+export {};

package/dist/packages/adapters/opencode/__tests__/native-hooks.spec.d.ts

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

package/dist/packages/adapters/opencode/__tests__/native-hooks.spec.js

@@ -0,0 +1,62 @@
+import { lstat, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ensureOpenCodeNativeHooksInstalled } from '../src/runtime/native-hooks';
+const tempDirs = [];
+const createTempDir = async (prefix) => {
+    const dir = await mkdtemp(join(tmpdir(), prefix));
+    tempDirs.push(dir);
+    return dir;
+};
+const writeDocument = async (filePath, content) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, content, { encoding: 'utf8', flag: 'w' });
+};
+afterEach(async () => {
+    delete process.env.__VF_PROJECT_REAL_HOME__;
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+describe('ensureOpenCodeNativeHooksInstalled', () => {
+    it('creates an isolated mock config dir and installs the managed plugin there', async () => {
+        const workspace = await createTempDir('opencode-hooks-workspace-');
+        const realHome = await createTempDir('opencode-hooks-home-');
+        const mockHome = join(workspace, '.ai', '.mock');
+        await writeDocument(join(realHome, '.config', 'opencode', 'opencode.json'), JSON.stringify({
+            $schema: 'https://opencode.ai/config.json'
+        }));
+        await writeDocument(join(realHome, '.config', 'opencode', 'commands', 'review.md'), '# review');
+        process.env.__VF_PROJECT_REAL_HOME__ = realHome;
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureOpenCodeNativeHooksInstalled(ctx);
+        const managedConfigDir = join(mockHome, '.config', 'opencode');
+        const pluginPath = join(managedConfigDir, 'plugins', 'vibe-forge-hooks.js');
+        expect(installed).toBe(true);
+        expect(ctx.env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__).toBe('1');
+        expect(ctx.env.OPENCODE_CONFIG_DIR).toBe(managedConfigDir);
+        expect((await lstat(managedConfigDir)).isDirectory()).toBe(true);
+        expect((await lstat(join(managedConfigDir, 'commands'))).isSymbolicLink()).toBe(true);
+        expect(await readFile(pluginPath, 'utf8')).toContain('tool.execute.before');
+        expect(JSON.parse(await readFile(join(managedConfigDir, 'opencode.json'), 'utf8'))).toMatchObject({
+            $schema: 'https://opencode.ai/config.json'
+        });
+    });
+});

package/dist/packages/adapters/opencode/__tests__/runtime-common.spec.d.ts

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

package/dist/packages/adapters/opencode/__tests__/runtime-common.spec.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import { resolveOpenCodeBinaryPath } from '#~/paths.js';
+import { buildOpenCodeRunArgs, buildOpenCodeSessionTitle, extractOpenCodeSessionRecords, normalizeOpenCodePrompt, resolveLocalAttachmentPath, resolveOpenCodeAgent, selectOpenCodeSessionByTitle } from '#~/runtime/common.js';
+describe('resolveOpenCodeBinaryPath', () => {
+    it('resolves to the adapter bundled binary by default', () => {
+        expect(resolveOpenCodeBinaryPath({})).toMatch(/node_modules\/\.bin\/opencode$/);
+    });
+    it('returns the env-specified path when set', () => {
+        expect(resolveOpenCodeBinaryPath({
+            __VF_PROJECT_AI_ADAPTER_OPENCODE_CLI_PATH__: '/usr/local/bin/opencode'
+        })).toBe('/usr/local/bin/opencode');
+    });
+});
+describe('openCode prompt and session helpers', () => {
+    it('normalizes prompt text and attachments', () => {
+        const result = normalizeOpenCodePrompt([
+            { type: 'text', text: 'Explain this diff' },
+            { type: 'image', url: 'file:///tmp/screenshot.png' }
+        ]);
+        expect(result.prompt).toBe('Explain this diff');
+        expect(result.files).toEqual(['/tmp/screenshot.png']);
+    });
+    it('builds a deterministic session title', () => {
+        expect(buildOpenCodeSessionTitle('session-1', 'VF')).toBe('VF:session-1');
+    });
+    it('filters managed CLI flags from passthrough options', () => {
+        expect(buildOpenCodeRunArgs({
+            prompt: 'hello',
+            files: ['/tmp/a.txt'],
+            model: 'openai/gpt-5',
+            title: 'VF:session-1',
+            extraOptions: ['--log-level', 'DEBUG', '--format', 'json', '--session', 'abc']
+        })).toEqual([
+            'run',
+            '--format',
+            'default',
+            '--title',
+            'VF:session-1',
+            '--model',
+            'openai/gpt-5',
+            '--file',
+            '/tmp/a.txt',
+            '--log-level',
+            'DEBUG',
+            'hello'
+        ]);
+    });
+    it('extracts session records from common JSON shapes', () => {
+        const records = extractOpenCodeSessionRecords({
+            sessions: [
+                { id: 'sess-old', title: 'VF:one', updatedAt: '2026-03-25T10:00:00.000Z' },
+                { sessionId: 'sess-new', title: 'VF:one', updated_at: '2026-03-25T11:00:00.000Z' }
+            ]
+        });
+        expect(records).toHaveLength(2);
+        expect(selectOpenCodeSessionByTitle(records, 'VF:one')?.id).toBe('sess-new');
+    });
+    it('resolves only local attachment paths', () => {
+        expect(resolveLocalAttachmentPath('file:///tmp/file.txt')).toBe('/tmp/file.txt');
+        expect(resolveLocalAttachmentPath('/tmp/file.txt')).toBe('/tmp/file.txt');
+        expect(resolveLocalAttachmentPath('https://example.com/file.txt')).toBeUndefined();
+    });
+    it('uses the plan agent by default in plan mode', () => {
+        expect(resolveOpenCodeAgent({ permissionMode: 'plan' })).toBe('plan');
+        expect(resolveOpenCodeAgent({
+            permissionMode: 'plan',
+            agent: 'build',
+            planAgent: false
+        })).toBe('build');
+        expect(resolveOpenCodeAgent({
+            permissionMode: 'plan',
+            agent: 'build',
+            planAgent: 'review'
+        })).toBe('review');
+    });
+});

package/dist/packages/adapters/opencode/__tests__/runtime-config.spec.d.ts

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

package/dist/packages/adapters/opencode/__tests__/runtime-config.spec.js

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest';
+import { buildInlineConfigContent, resolveOpenCodeModel } from '#~/runtime/common.js';
+describe('openCode config and model helpers', () => {
+    it('builds inline config overrides for permissions, mcp, tools, and instructions', () => {
+        const config = buildInlineConfigContent({
+            envConfigContent: {
+                instructions: ['CONTRIBUTING.md']
+            },
+            adapterConfigContent: {
+                provider: {
+                    existing: {
+                        name: 'Existing'
+                    }
+                }
+            },
+            permissionMode: 'default',
+            tools: {
+                exclude: ['write']
+            },
+            mcpServers: {
+                include: ['local-docs']
+            },
+            availableMcpServers: {
+                'local-docs': {
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-everything']
+                }
+            },
+            systemPromptFile: '/tmp/system.md',
+            providerConfig: {
+                custom: {
+                    npm: '@ai-sdk/openai-compatible'
+                }
+            }
+        });
+        expect(config).toMatchObject({
+            instructions: ['CONTRIBUTING.md', '/tmp/system.md'],
+            permission: {
+                '*': 'allow',
+                bash: 'ask',
+                edit: 'deny',
+                task: 'ask'
+            },
+            tools: {
+                write: false
+            },
+            mcp: {
+                'local-docs': {
+                    type: 'local',
+                    command: ['npx', '-y', '@modelcontextprotocol/server-everything'],
+                    enabled: true
+                }
+            },
+            provider: {
+                existing: {
+                    name: 'Existing'
+                },
+                custom: {
+                    npm: '@ai-sdk/openai-compatible'
+                }
+            }
+        });
+    });
+    it('maps custom model services to an OpenCode provider/model pair', () => {
+        const result = resolveOpenCodeModel('gateway,gpt-5', {
+            gateway: {
+                apiBaseUrl: 'https://example.test/v1',
+                apiKey: 'secret',
+                title: 'Gateway',
+                timeoutMs: 600000,
+                maxOutputTokens: 8192
+            }
+        });
+        expect(result.cliModel).toBe('gateway/gpt-5');
+        expect(result.providerConfig).toMatchObject({
+            gateway: {
+                npm: '@ai-sdk/openai-compatible',
+                options: {
+                    apiKey: 'secret',
+                    baseURL: 'https://example.test/v1',
+                    timeout: 600000,
+                    chunkTimeout: 600000
+                },
+                models: {
+                    'gpt-5': {
+                        name: 'gpt-5',
+                        limit: {
+                            output: 8192
+                        },
+                        options: {
+                            maxOutputTokens: 8192
+                        }
+                    }
+                }
+            }
+        });
+    });
+    it('preserves provider prefix when explicit service syntax has no local mapping', () => {
+        expect(resolveOpenCodeModel('openrouter,claude-sonnet-4.5', {})).toEqual({
+            cliModel: 'openrouter/claude-sonnet-4.5',
+            providerConfig: undefined
+        });
+    });
+    it('does not inject permission overrides when no runtime permission inputs are provided', () => {
+        expect(buildInlineConfigContent({})).not.toHaveProperty('permission');
+    });
+    it('preserves inherited string permission config when runtime permission is unset', () => {
+        expect(buildInlineConfigContent({
+            adapterConfigContent: {
+                permission: 'ask'
+            }
+        })).toMatchObject({
+            permission: 'ask'
+        });
+    });
+});

package/dist/packages/adapters/opencode/__tests__/runtime-permissions.spec.d.ts

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