@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/adapters/claude-code/src/runtime/session.js

@@ -0,0 +1,261 @@
+import { spawn } from 'node:child_process';
+import { uuid } from '@vibe-forge/utils/uuid';
+import { mapAdapterContentToClaudeContent } from '../protocol/content';
+import { handleIncomingEvent } from '../protocol/incoming';
+import { prepareClaudeExecution } from './prepare';
+const stripAnsiSequences = (value) => {
+    let output = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.charCodeAt(index) === 27 && value[index + 1] === '[') {
+            index += 2;
+            while (index < value.length) {
+                const code = value.charCodeAt(index);
+                if (code >= 64 && code <= 126) {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        output += value[index];
+        index += 1;
+    }
+    return output;
+};
+export const createClaudeSession = async (ctx, options) => {
+    const { logger } = ctx;
+    const { onEvent, description, mode = 'stream', extraOptions } = options;
+    const { cliPath, args, env, cwd, sessionId, executionType } = await prepareClaudeExecution(ctx, options);
+    let didEmitFatalError = false;
+    const emitEvent = (event) => {
+        if (event.type === 'error' && event.data.fatal !== false) {
+            didEmitFatalError = true;
+        }
+        onEvent(event);
+    };
+    if (mode === 'stream') {
+        args.push('--print', '--verbose', '--debug', '--output-format', 'stream-json', '--input-format', 'stream-json', ...(extraOptions ?? []));
+        logger.info('Claude Code CLI command:', {
+            cliPath,
+            args,
+            mode
+        });
+        const proc = spawn(cliPath, args, {
+            env: { ...env, FORCE_COLOR: '1' },
+            cwd,
+            stdio: 'pipe'
+        });
+        let stdoutBuffer = '';
+        let canResumeMarked = executionType === 'resume';
+        const markResumeReady = async () => {
+            if (canResumeMarked)
+                return;
+            canResumeMarked = true;
+            await ctx.cache.set('adapter.claude-code.resume-state', { canResume: true });
+        };
+        const clearResumeReady = async () => {
+            canResumeMarked = false;
+            await ctx.cache.set('adapter.claude-code.resume-state', { canResume: false });
+        };
+        proc.stdout.on('data', (buf) => {
+            const rawStr = String(buf);
+            stdoutBuffer += rawStr;
+            const lines = stdoutBuffer.split('\n');
+            stdoutBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                logger.debug('Claude Code CLI stdout:', { line });
+                const cleanedLine = stripAnsiSequences(line);
+                const trimmed = cleanedLine.trim();
+                if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (parsed.type === 'result' &&
+                            parsed.subtype === 'error_during_execution' &&
+                            parsed.errors.some(error => error.includes(`No conversation found with session ID: ${sessionId}`))) {
+                            void clearResumeReady();
+                        }
+                        if (executionType === 'create' &&
+                            ((parsed.type === 'system' && parsed.subtype === 'init') ||
+                                parsed.type === 'assistant' ||
+                                (parsed.type === 'result' && parsed.subtype === 'success'))) {
+                            void markResumeReady();
+                        }
+                        handleIncomingEvent(parsed, emitEvent);
+                    }
+                    catch (err) {
+                        console.error('Failed to parse JSON:', trimmed, err);
+                    }
+                }
+            }
+        });
+        const stderrBuffer = [];
+        proc.stderr.on('data', (buf) => {
+            const rawStr = String(buf);
+            stderrBuffer.push(rawStr);
+        });
+        let didEmitExit = false;
+        const emitExit = (data) => {
+            if (didEmitExit)
+                return;
+            didEmitExit = true;
+            emitEvent({
+                type: 'exit',
+                data
+            });
+        };
+        proc.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: {
+                        message,
+                        details: err,
+                        fatal: true
+                    }
+                });
+            }
+            emitExit({
+                exitCode: 1,
+                stderr: message
+            });
+        });
+        proc.on('exit', (code) => {
+            const stderr = stderrBuffer.join('');
+            if ((code ?? 0) !== 0 && !didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: {
+                        message: stderr !== '' ? stderr : `Process exited with code ${code ?? 1}`,
+                        details: stderr !== '' ? { stderr } : { exitCode: code ?? 1 },
+                        fatal: true
+                    }
+                });
+            }
+            emitExit({
+                exitCode: code ?? undefined,
+                stderr
+            });
+        });
+        const emit = (event) => {
+            let outputEvent = {
+                uuid: uuid(),
+                timestamp: new Date().toISOString(),
+                sessionId,
+                cwd
+            };
+            switch (event.type) {
+                case 'message': {
+                    outputEvent = {
+                        ...outputEvent,
+                        type: 'user',
+                        parentUuid: event.parentUuid ?? null,
+                        message: {
+                            id: `msg_${Date.now()}`,
+                            type: 'message',
+                            role: 'user',
+                            content: mapAdapterContentToClaudeContent(event.content),
+                            uuid: uuid()
+                        }
+                    };
+                    break;
+                }
+                case 'interrupt': {
+                    outputEvent = {
+                        ...outputEvent,
+                        type: 'user',
+                        message: {
+                            role: 'user',
+                            content: [{ type: 'text', text: '[Request interrupted by user]' }]
+                        }
+                    };
+                    break;
+                }
+                case 'stop': {
+                    proc.stdin.end();
+                    return;
+                }
+                default:
+                    logger.warn('Unknown event:', event);
+                    break;
+            }
+            proc.stdin.write(`${JSON.stringify(outputEvent)}\n`);
+        };
+        if (description) {
+            emit({
+                type: 'message',
+                content: [
+                    { type: 'text', text: description }
+                ]
+            });
+        }
+        return {
+            kill: () => proc.kill(),
+            emit,
+            pid: proc.pid
+        };
+    }
+    args.push(...(extraOptions ?? []));
+    logger.info('Claude Code CLI command:', {
+        cliPath,
+        args,
+        extraOptions,
+        mode
+    });
+    const proc = spawn(cliPath, args, {
+        env: { ...env, FORCE_COLOR: '1' },
+        cwd,
+        stdio: 'inherit'
+    });
+    let didEmitExit = false;
+    const emitExit = (data) => {
+        if (didEmitExit)
+            return;
+        didEmitExit = true;
+        emitEvent({
+            type: 'exit',
+            data
+        });
+    };
+    proc.on('error', (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        if (!didEmitFatalError) {
+            emitEvent({
+                type: 'error',
+                data: {
+                    message,
+                    details: err,
+                    fatal: true
+                }
+            });
+        }
+        emitExit({
+            exitCode: 1,
+            stderr: message
+        });
+    });
+    proc.on('exit', (code) => {
+        if ((code ?? 0) !== 0 && !didEmitFatalError) {
+            emitEvent({
+                type: 'error',
+                data: {
+                    message: `Process exited with code ${code ?? 1}`,
+                    details: { exitCode: code ?? 1 },
+                    fatal: true
+                }
+            });
+        }
+        emitExit({
+            exitCode: code ?? undefined
+        });
+    });
+    return {
+        kill: () => proc.kill(),
+        emit: () => {
+            console.warn('emit() is not supported in direct mode');
+        },
+        pid: proc.pid
+    };
+};

package/dist/packages/adapters/claude-code/src/schema.d.ts

@@ -0,0 +1,199 @@
+export interface TaskToolInput {
+    description: string;
+    prompt: string;
+    subagent_type: string;
+    model?: 'sonnet' | 'opus' | 'haiku';
+    resume?: string;
+    run_in_background?: boolean;
+    max_turns?: number;
+}
+export interface BashToolInput {
+    command: string;
+    timeout?: number;
+    description?: string;
+    reason?: string;
+    thought?: string;
+    run_in_background?: boolean;
+    dangerouslyDisableSandbox?: boolean;
+    _simulatedSedEdit?: {
+        filePath: string;
+        newContent: string;
+    };
+}
+export interface GlobToolInput {
+    pattern: string;
+    path?: string;
+}
+export interface GrepToolInput {
+    pattern: string;
+    path?: string;
+    glob?: string;
+    output_mode?: 'content' | 'files_with_matches' | 'count';
+    '-B'?: number;
+    '-A'?: number;
+    '-C'?: number;
+    context?: number;
+    '-n'?: boolean;
+    '-i'?: boolean;
+    type?: string;
+    head_limit?: number;
+    offset?: number;
+    multiline?: boolean;
+}
+export interface ExitPlanModeToolInput {
+    allowedPrompts?: Array<{
+        tool: 'Bash';
+        prompt: string;
+    }>;
+    pushToRemote?: boolean;
+    remoteSessionId?: string;
+    remoteSessionUrl?: string;
+    remoteSessionTitle?: string;
+}
+export interface ReadToolInput {
+    file_path: string;
+    offset?: number;
+    limit?: number;
+}
+export interface EditToolInput {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+    replace_all?: boolean;
+}
+export interface WriteToolInput {
+    file_path: string;
+    content: string;
+}
+export interface NotebookEditToolInput {
+    notebook_path: string;
+    cell_id?: string;
+    new_source: string;
+    cell_type?: 'code' | 'markdown';
+    edit_mode?: 'replace' | 'insert' | 'delete';
+}
+export interface WebFetchToolInput {
+    url: string;
+    prompt: string;
+}
+export interface WebSearchToolInput {
+    query: string;
+    allowed_domains?: string[];
+    blocked_domains?: string[];
+}
+export interface AskUserQuestionToolInput {
+    questions: Array<{
+        question: string;
+        header: string;
+        options: Array<{
+            label: string;
+            description: string;
+        }>;
+        multiSelect: boolean;
+    }>;
+    answers?: Record<string, string>;
+    metadata?: {
+        source?: string;
+    };
+}
+export interface SkillToolInput {
+    skill: string;
+    args?: string;
+}
+export interface EnterPlanModeToolInput {
+}
+export interface TaskCreateToolInput {
+    subject: string;
+    description: string;
+    activeForm?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TaskGetToolInput {
+    taskId: string;
+}
+export interface TaskUpdateToolInput {
+    taskId: string;
+    subject?: string;
+    description?: string;
+    activeForm?: string;
+    status?: 'pending' | 'in_progress' | 'completed' | 'deleted';
+    addBlocks?: string[];
+    addBlockedBy?: string[];
+    owner?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TaskListToolInput {
+}
+export interface LSToolInput {
+    path?: string;
+    ignore?: string[];
+}
+export interface TodoItem {
+    id?: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    priority?: string;
+    activeForm?: string;
+}
+export interface TodoWriteToolInput {
+    todos: TodoItem[];
+    merge: boolean;
+    summary?: string;
+}
+export interface ClaudeToolInputs {
+    'adapter:claude-code:Task': TaskToolInput;
+    'adapter:claude-code:Bash': BashToolInput;
+    'adapter:claude-code:Glob': GlobToolInput;
+    'adapter:claude-code:Grep': GrepToolInput;
+    'adapter:claude-code:ExitPlanMode': ExitPlanModeToolInput;
+    'adapter:claude-code:Read': ReadToolInput;
+    'adapter:claude-code:Edit': EditToolInput;
+    'adapter:claude-code:Write': WriteToolInput;
+    'adapter:claude-code:NotebookEdit': NotebookEditToolInput;
+    'adapter:claude-code:WebFetch': WebFetchToolInput;
+    'adapter:claude-code:WebSearch': WebSearchToolInput;
+    'adapter:claude-code:AskUserQuestion': AskUserQuestionToolInput;
+    'adapter:claude-code:Skill': SkillToolInput;
+    'adapter:claude-code:EnterPlanMode': EnterPlanModeToolInput;
+    'adapter:claude-code:TaskCreate': TaskCreateToolInput;
+    'adapter:claude-code:TaskGet': TaskGetToolInput;
+    'adapter:claude-code:TaskUpdate': TaskUpdateToolInput;
+    'adapter:claude-code:TaskList': TaskListToolInput;
+    'adapter:claude-code:LS': LSToolInput;
+    'adapter:claude-code:TodoWrite': TodoWriteToolInput;
+}
+export interface ClaudeToolOutputs {
+    'adapter:claude-code:Read': {
+        type: 'text' | (string & {});
+        file: {
+            filePath: string;
+            content: string;
+            numLines: number;
+            startLine: number;
+            totalLines: number;
+        };
+    };
+    'adapter:claude-code:LS': string;
+    'adapter:claude-code:Edit': {
+        filePath: string;
+        newString: string;
+        oldString: string;
+        originalFile: string;
+    };
+    'adapter:claude-code:Write': {
+        filePath: string;
+        content: string;
+    };
+    'adapter:claude-code:Bash': {
+        stdout: string;
+        stderr: string;
+        interrupted: boolean;
+        isImage: boolean;
+    };
+}
+declare module '@vibe-forge/core' {
+    interface ToolInputs extends ClaudeToolInputs {
+    }
+    interface ToolOutputs extends ClaudeToolOutputs {
+    }
+}

package/dist/packages/adapters/claude-code/src/schema.js

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

package/dist/packages/adapters/claude-code/src/types.d.ts

@@ -0,0 +1,116 @@
+export interface ClaudeCodeBaseEvent {
+    uuid: string;
+    timestamp: string;
+    sessionId: string;
+    cwd: string;
+    version?: string;
+    gitBranch?: string;
+    parentUuid?: string | null;
+    isSidechain?: boolean;
+    userType?: string;
+}
+export interface ClaudeCodeContentText {
+    type: 'text';
+    text: string;
+}
+export interface ClaudeCodeContentImage {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+}
+export interface ClaudeCodeContentToolUse {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+}
+export interface ClaudeCodeContentToolResult {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | unknown[];
+    is_error?: boolean;
+}
+export type ClaudeCodeContent = ClaudeCodeContentText | ClaudeCodeContentImage | ClaudeCodeContentToolUse | ClaudeCodeContentToolResult;
+export interface ClaudeCodeUserMessage {
+    id?: string;
+    type?: string;
+    role: 'user';
+    content: string | ClaudeCodeContent[];
+    uuid?: string;
+}
+export interface ClaudeCodeUserEvent extends ClaudeCodeBaseEvent {
+    type: 'user';
+    message: ClaudeCodeUserMessage;
+}
+export interface ClaudeCodeAssistantMessage {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: ClaudeCodeContent[];
+    model: string;
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens: number;
+    };
+    uuid?: string;
+}
+export interface ClaudeCodeAssistantEvent extends ClaudeCodeBaseEvent {
+    type: 'assistant';
+    message: ClaudeCodeAssistantMessage;
+    model?: string;
+}
+export interface ClaudeCodeSystemInitEvent extends ClaudeCodeBaseEvent {
+    type: 'system';
+    subtype: 'init';
+    session_id?: string;
+    model: string;
+    claude_code_version: string;
+    tools: unknown[];
+    slash_commands: unknown[];
+    agents: unknown[];
+}
+export interface ClaudeCodeSummaryEvent {
+    type: 'summary';
+    summary: string;
+    leafUuid: string;
+}
+export interface ClaudeCodeResultEvent extends ClaudeCodeBaseEvent {
+    type: 'result';
+    subtype: 'success';
+    is_error: boolean;
+    duration_ms: number;
+    duration_api_ms: number;
+    num_turns: number;
+    result: string;
+    session_id: string;
+    total_cost_usd: number;
+    usage: {
+        input_tokens: number;
+        cache_creation_input_tokens: number;
+        cache_read_input_tokens: number;
+        output_tokens: number;
+        server_tool_use?: {
+            web_search_requests: number;
+        };
+        service_tier?: string;
+        cache_creation?: {
+            ephemeral_1h_input_tokens: number;
+            ephemeral_5m_input_tokens: number;
+        };
+    };
+    permission_denials: unknown[];
+}
+export interface ClaudeCodeErrorResultEvent extends ClaudeCodeBaseEvent {
+    type: 'result';
+    subtype: 'error_during_execution';
+    session_id?: string;
+    errors: string[];
+}
+export type ClaudeCodeIncomingEvent = ClaudeCodeUserEvent | ClaudeCodeAssistantEvent | ClaudeCodeSystemInitEvent | ClaudeCodeSummaryEvent | ClaudeCodeResultEvent | ClaudeCodeErrorResultEvent;

package/dist/packages/adapters/claude-code/src/types.js

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

package/dist/packages/adapters/codex/__tests__/hook-bridge.spec.d.ts

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

package/dist/packages/adapters/codex/__tests__/hook-bridge.spec.js

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { mapCodexHookInputToVibeForge, mapVibeForgeHookOutputToCodex } from '../src/hook-bridge';
+describe('codex native hook bridge helpers', () => {
+    it('maps Codex native hooks into the unified hook shape', () => {
+        const result = mapCodexHookInputToVibeForge({
+            cwd: '/tmp/project',
+            sessionId: 'session-1',
+            transcriptPath: '/tmp/transcript.jsonl',
+            hookEventName: 'PostToolUse',
+            turnId: 'turn-1',
+            toolUseId: 'tool-1',
+            toolName: 'Bash',
+            toolInput: {
+                command: 'cat README.md'
+            },
+            toolResponse: {
+                content: 'hello'
+            }
+        });
+        expect(result).toMatchObject({
+            adapter: 'codex',
+            hookSource: 'native',
+            canBlock: true,
+            transcriptPath: '/tmp/transcript.jsonl',
+            turnId: 'turn-1',
+            hookEventName: 'PostToolUse',
+            toolCallId: 'tool-1',
+            toolName: 'Bash'
+        });
+    });
+    it('maps blocked Vibe Forge output back into Codex pre-tool decision fields', () => {
+        const result = mapVibeForgeHookOutputToCodex('PreToolUse', {
+            continue: false,
+            stopReason: 'blocked'
+        });
+        expect(result).toMatchObject({
+            decision: 'block',
+            reason: 'blocked',
+            hookSpecificOutput: {
+                hookEventName: 'PreToolUse',
+                permissionDecision: 'deny',
+                permissionDecisionReason: 'blocked'
+            }
+        });
+        expect(result).not.toHaveProperty('continue');
+    });
+    it('keeps Stop continue semantics instead of converting them into continuation prompts', () => {
+        const result = mapVibeForgeHookOutputToCodex('Stop', {
+            continue: false,
+            stopReason: 'stop here'
+        });
+        expect(result).toMatchObject({
+            continue: false,
+            stopReason: 'stop here'
+        });
+        expect(result).not.toHaveProperty('decision');
+    });
+    it('passes UserPromptSubmit additional context through the documented hook-specific output', () => {
+        const result = mapVibeForgeHookOutputToCodex('UserPromptSubmit', {
+            hookSpecificOutput: {
+                hookEventName: 'UserPromptSubmit',
+                additionalContext: 'Ask for a clearer reproduction before editing files.'
+            }
+        });
+        expect(result).toMatchObject({
+            hookSpecificOutput: {
+                hookEventName: 'UserPromptSubmit',
+                additionalContext: 'Ask for a clearer reproduction before editing files.'
+            }
+        });
+    });
+});

package/dist/packages/adapters/codex/__tests__/incoming.spec.d.ts

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