@ruvnet/open-claude-code 2.0.0

package/src/core/session.mjs

@@ -0,0 +1,143 @@
+/**
+ * Session Manager — save, resume, and teleport sessions.
+ *
+ * Sessions are stored at ~/.claude/projects/<hash>/session.json
+ * and contain conversation history, token usage, and metadata.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export class SessionManager {
+    constructor(projectDir = process.cwd()) {
+        this.projectDir = projectDir;
+        this.sessionId = `sess_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+        this.conversationId = null;
+        this.startedAt = new Date().toISOString();
+    }
+
+    /**
+     * Get the session storage directory for the current project.
+     */
+    getSessionDir() {
+        const hash = crypto.createHash('sha256')
+            .update(this.projectDir)
+            .digest('hex')
+            .slice(0, 16);
+
+        return path.join(os.homedir(), '.claude', 'projects', hash);
+    }
+
+    /**
+     * Save the current session state.
+     * @param {object} state - agent loop state to save
+     */
+    save(state) {
+        const dir = this.getSessionDir();
+        fs.mkdirSync(dir, { recursive: true });
+
+        const session = {
+            id: this.sessionId,
+            conversationId: this.conversationId,
+            projectDir: this.projectDir,
+            startedAt: this.startedAt,
+            savedAt: new Date().toISOString(),
+            model: state.model,
+            turnCount: state.turnCount,
+            tokenUsage: state.tokenUsage,
+            messages: state.messages,
+            systemPrompt: state.systemPrompt,
+        };
+
+        const filePath = path.join(dir, 'session.json');
+        fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+        return filePath;
+    }
+
+    /**
+     * Resume a saved session.
+     * @param {object} state - agent loop state to restore into
+     * @returns {boolean} true if session was restored
+     */
+    resume(state) {
+        const dir = this.getSessionDir();
+        const filePath = path.join(dir, 'session.json');
+
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const session = JSON.parse(raw);
+
+            state.messages = session.messages || [];
+            state.turnCount = session.turnCount || 0;
+            state.tokenUsage = session.tokenUsage || { input: 0, output: 0 };
+            if (session.model) state.model = session.model;
+
+            this.sessionId = session.id;
+            this.conversationId = session.conversationId;
+            this.startedAt = session.startedAt;
+
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Export session for teleport (transfer between machines).
+     * @param {object} state - agent loop state
+     * @returns {string} base64-encoded session data
+     */
+    exportForTeleport(state) {
+        const session = {
+            id: this.sessionId,
+            projectDir: this.projectDir,
+            messages: state.messages,
+            turnCount: state.turnCount,
+            model: state.model,
+            exportedAt: new Date().toISOString(),
+        };
+
+        return Buffer.from(JSON.stringify(session)).toString('base64');
+    }
+
+    /**
+     * Import a teleported session.
+     * @param {string} data - base64-encoded session data
+     * @param {object} state - agent loop state to restore into
+     */
+    importFromTeleport(data, state) {
+        const session = JSON.parse(Buffer.from(data, 'base64').toString());
+        state.messages = session.messages || [];
+        state.turnCount = session.turnCount || 0;
+        if (session.model) state.model = session.model;
+        this.sessionId = `sess_teleport_${Date.now()}`;
+    }
+
+    /**
+     * Get session info.
+     */
+    info() {
+        return {
+            id: this.sessionId,
+            conversationId: this.conversationId,
+            projectDir: this.projectDir,
+            startedAt: this.startedAt,
+            sessionDir: this.getSessionDir(),
+        };
+    }
+
+    /**
+     * Delete the saved session.
+     */
+    clear() {
+        const filePath = path.join(this.getSessionDir(), 'session.json');
+        try {
+            fs.unlinkSync(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}

package/src/core/streaming.mjs

@@ -0,0 +1,182 @@
+/**
+ * Streaming Handler — processes Anthropic SSE events from the Messages API.
+ *
+ * Handles ALL SSE event types:
+ * - message_start, message_delta, message_stop
+ * - content_block_start, content_block_delta, content_block_stop
+ * - ping
+ * - error
+ *
+ * Parses:
+ * - thinking blocks (type: "thinking")
+ * - tool_use input streaming (type: "input_json_delta")
+ * - Usage tracking from message_delta.usage
+ */
+
+/**
+ * Parse an SSE stream from an Anthropic streaming response.
+ * @param {Response} response - fetch Response with streaming body
+ * @yields {object} Parsed SSE event data
+ */
+export async function* streamResponse(response) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+
+            // SSE events are separated by double newlines
+            while (buffer.includes('\n\n')) {
+                const idx = buffer.indexOf('\n\n');
+                const chunk = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 2);
+
+                const event = parseSSEChunk(chunk);
+                if (event) yield event;
+            }
+        }
+
+        // Handle remaining buffer
+        if (buffer.trim()) {
+            const event = parseSSEChunk(buffer.trim());
+            if (event) yield event;
+        }
+    } finally {
+        reader.releaseLock();
+    }
+}
+
+/**
+ * Parse a single SSE chunk into an event object.
+ * @param {string} chunk - raw SSE text (may contain event: and data: lines)
+ * @returns {object|null} Parsed event or null
+ */
+function parseSSEChunk(chunk) {
+    let eventType = null;
+    let dataLines = [];
+
+    for (const line of chunk.split('\n')) {
+        if (line.startsWith('event: ')) {
+            eventType = line.slice(7).trim();
+        } else if (line.startsWith('data: ')) {
+            dataLines.push(line.slice(6));
+        } else if (line.startsWith(':')) {
+            // SSE comment, ignore
+            continue;
+        }
+    }
+
+    // Handle ping events (no data)
+    if (eventType === 'ping') {
+        return { type: 'ping' };
+    }
+
+    if (dataLines.length === 0) return null;
+
+    const raw = dataLines.join('\n');
+    if (raw === '[DONE]') return { type: 'done' };
+
+    try {
+        const data = JSON.parse(raw);
+        return { type: eventType || data.type || 'unknown', ...data };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Accumulate streaming events into a complete message response.
+ * Collects content blocks, thinking blocks, and usage stats.
+ *
+ * @param {AsyncIterable} events - stream of SSE events
+ * @returns {object} Complete message in the same shape as non-streaming API
+ */
+export async function accumulateStream(events) {
+    const message = {
+        id: null,
+        role: 'assistant',
+        content: [],
+        model: null,
+        stop_reason: null,
+        usage: { input_tokens: 0, output_tokens: 0, cache_creation_input_tokens: 0, cache_read_input_tokens: 0 },
+    };
+
+    let currentBlock = null;
+    let blockIndex = -1;
+
+    for await (const event of events) {
+        switch (event.type) {
+            case 'message_start':
+                if (event.message) {
+                    message.id = event.message.id;
+                    message.model = event.message.model;
+                    if (event.message.usage) {
+                        message.usage.input_tokens = event.message.usage.input_tokens || 0;
+                        message.usage.cache_creation_input_tokens = event.message.usage.cache_creation_input_tokens || 0;
+                        message.usage.cache_read_input_tokens = event.message.usage.cache_read_input_tokens || 0;
+                    }
+                }
+                break;
+
+            case 'content_block_start':
+                blockIndex = event.index ?? message.content.length;
+                currentBlock = { ...event.content_block };
+                if (currentBlock.type === 'text') currentBlock.text = '';
+                if (currentBlock.type === 'thinking') currentBlock.thinking = '';
+                if (currentBlock.type === 'tool_use') {
+                    currentBlock.input = '';
+                }
+                message.content[blockIndex] = currentBlock;
+                break;
+
+            case 'content_block_delta':
+                if (!currentBlock) break;
+                if (event.delta?.type === 'text_delta') {
+                    currentBlock.text += event.delta.text;
+                } else if (event.delta?.type === 'thinking_delta') {
+                    currentBlock.thinking += event.delta.thinking;
+                } else if (event.delta?.type === 'input_json_delta') {
+                    currentBlock.input += event.delta.partial_json;
+                }
+                break;
+
+            case 'content_block_stop':
+                // Parse tool_use input from accumulated JSON string
+                if (currentBlock?.type === 'tool_use' && typeof currentBlock.input === 'string') {
+                    try {
+                        currentBlock.input = JSON.parse(currentBlock.input || '{}');
+                    } catch {
+                        currentBlock.input = {};
+                    }
+                }
+                currentBlock = null;
+                break;
+
+            case 'message_delta':
+                if (event.delta?.stop_reason) {
+                    message.stop_reason = event.delta.stop_reason;
+                }
+                if (event.usage) {
+                    message.usage.output_tokens = event.usage.output_tokens || 0;
+                }
+                break;
+
+            case 'message_stop':
+                break;
+
+            case 'ping':
+                // Keepalive, ignore
+                break;
+
+            case 'error':
+                throw new Error(`Stream error: ${event.error?.message || JSON.stringify(event)}`);
+        }
+    }
+
+    return message;
+}

package/src/core/system-prompt.mjs

@@ -0,0 +1,135 @@
+/**
+ * System Prompt Builder — loads and merges CLAUDE.md files.
+ *
+ * Features:
+ * - Loads CLAUDE.md from: ~/.claude/CLAUDE.md, project root, parent dirs
+ * - Merges in order (global -> project -> local)
+ * - Splits at cache boundary (static prefix cached, dynamic suffix not)
+ * - Includes tool schemas in the system prompt
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Load all CLAUDE.md files and merge them in order.
+ * @param {string} [cwd] - current working directory
+ * @returns {string[]} Array of CLAUDE.md contents in merge order
+ */
+export function loadClaudeMdFiles(cwd = process.cwd()) {
+    const files = [];
+
+    // 1. Global: ~/.claude/CLAUDE.md
+    const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+    if (fs.existsSync(globalPath)) {
+        try {
+            files.push({ source: 'global', content: fs.readFileSync(globalPath, 'utf-8') });
+        } catch { /* skip */ }
+    }
+
+    // 2. Walk from cwd up to root, collecting CLAUDE.md files
+    const projectFiles = [];
+    let dir = path.resolve(cwd);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const candidates = [
+            path.join(dir, 'CLAUDE.md'),
+            path.join(dir, '.claude', 'CLAUDE.md'),
+        ];
+        for (const f of candidates) {
+            if (fs.existsSync(f)) {
+                try {
+                    projectFiles.push({ source: dir, content: fs.readFileSync(f, 'utf-8'), path: f });
+                } catch { /* skip */ }
+            }
+        }
+        dir = path.dirname(dir);
+    }
+
+    // Reverse so parent dirs come first (global -> project -> local)
+    projectFiles.reverse();
+    files.push(...projectFiles);
+
+    return files;
+}
+
+/**
+ * Build the full system prompt from CLAUDE.md files and tool schemas.
+ * @param {object} options
+ * @param {string} [options.cwd] - current working directory
+ * @param {Array} [options.tools] - tool definitions for schema inclusion
+ * @param {string} [options.override] - override system prompt entirely
+ * @param {string[]} [options.addDirs] - additional directories to search for CLAUDE.md
+ * @returns {{ staticPrefix: string, dynamicSuffix: string, full: string }}
+ */
+export function buildSystemPrompt({ cwd, tools, override, addDirs } = {}) {
+    if (override) {
+        return { staticPrefix: override, dynamicSuffix: '', full: override };
+    }
+
+    const parts = ['You are an AI coding assistant.'];
+
+    // Load CLAUDE.md files
+    const mdFiles = loadClaudeMdFiles(cwd);
+
+    // Add additional directories
+    if (addDirs) {
+        for (const dir of addDirs) {
+            const p = path.join(dir, 'CLAUDE.md');
+            if (fs.existsSync(p)) {
+                try {
+                    mdFiles.push({ source: dir, content: fs.readFileSync(p, 'utf-8') });
+                } catch { /* skip */ }
+            }
+        }
+    }
+
+    for (const f of mdFiles) {
+        parts.push(f.content);
+    }
+
+    // The static prefix is the base prompt + CLAUDE.md content (cacheable)
+    const staticPrefix = parts.join('\n\n');
+
+    // Dynamic suffix includes tool schemas (changes per-request)
+    let dynamicSuffix = '';
+    if (tools && tools.length > 0) {
+        const toolSummary = tools.map(t =>
+            `- ${t.name}: ${(t.description || '').slice(0, 100)}`
+        ).join('\n');
+        dynamicSuffix = `\n\nAvailable tools:\n${toolSummary}`;
+    }
+
+    return {
+        staticPrefix,
+        dynamicSuffix,
+        full: staticPrefix + dynamicSuffix,
+    };
+}
+
+/**
+ * Convert system prompt to Anthropic cache-control format.
+ * @param {string} staticPrefix
+ * @param {string} dynamicSuffix
+ * @returns {Array} system blocks with cache_control
+ */
+export function toCacheBlocks(staticPrefix, dynamicSuffix) {
+    const blocks = [];
+
+    if (staticPrefix) {
+        blocks.push({
+            type: 'text',
+            text: staticPrefix,
+            cache_control: { type: 'ephemeral' },
+        });
+    }
+
+    if (dynamicSuffix) {
+        blocks.push({
+            type: 'text',
+            text: dynamicSuffix,
+        });
+    }
+
+    return blocks;
+}

package/src/hooks/engine.mjs

@@ -0,0 +1,162 @@
+/**
+ * Hook Engine — pre/post tool use and stop hooks.
+ *
+ * Based on Claude Code's hooks system (6 event types):
+ * - PreToolUse: can block tool execution
+ * - PostToolUse: can modify results
+ * - Stop: can prevent the agent from stopping
+ * - Notification: inform external systems
+ * - PrePrompt: modify user input
+ * - PostResponse: modify assistant output
+ *
+ * Hooks are defined in settings.json under the "hooks" key.
+ */
+
+import { execSync } from 'child_process';
+
+export class HookEngine {
+    /**
+     * @param {object} hooksConfig - hooks configuration from settings
+     */
+    constructor(hooksConfig = {}) {
+        this.hooks = hooksConfig;
+    }
+
+    /**
+     * Run pre-tool-use hooks. Returns { allow, message }.
+     * If any hook returns deny, the tool call is blocked.
+     *
+     * @param {string} toolName - name of the tool being called
+     * @param {object} input - tool input arguments
+     * @returns {Promise<{allow: boolean, message?: string}>}
+     */
+    async runPreToolUse(toolName, input) {
+        const hooks = this._getHooks('PreToolUse');
+        for (const hook of hooks) {
+            // Check if hook applies to this tool
+            if (hook.toolName && hook.toolName !== toolName) continue;
+
+            const result = await this._executeHook(hook, {
+                event: 'PreToolUse',
+                toolName,
+                input,
+            });
+
+            if (result?.decision === 'deny' || result?.decision === 'block') {
+                return { allow: false, message: result.message || `Blocked by hook: ${hook.name || 'unnamed'}` };
+            }
+        }
+        return { allow: true };
+    }
+
+    /**
+     * Run post-tool-use hooks. Can modify the result.
+     *
+     * @param {string} toolName - name of the tool that was called
+     * @param {*} result - tool execution result
+     * @returns {Promise<*>} possibly modified result
+     */
+    async runPostToolUse(toolName, result) {
+        const hooks = this._getHooks('PostToolUse');
+        let current = result;
+        for (const hook of hooks) {
+            if (hook.toolName && hook.toolName !== toolName) continue;
+
+            const hookResult = await this._executeHook(hook, {
+                event: 'PostToolUse',
+                toolName,
+                result: current,
+            });
+
+            if (hookResult?.modifiedResult !== undefined) {
+                current = hookResult.modifiedResult;
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Run stop hooks. Returns true if stop should proceed, false to continue.
+     *
+     * @returns {Promise<boolean>} whether to allow stopping
+     */
+    async runStop() {
+        const hooks = this._getHooks('Stop');
+        for (const hook of hooks) {
+            const result = await this._executeHook(hook, { event: 'Stop' });
+            if (result?.preventStop) {
+                return false; // do not stop
+            }
+        }
+        return true; // allow stop
+    }
+
+    /**
+     * Run notification hooks (fire-and-forget).
+     * @param {string} event - notification event name
+     * @param {object} data - event data
+     */
+    async runNotification(event, data) {
+        const hooks = this._getHooks('Notification');
+        for (const hook of hooks) {
+            try {
+                await this._executeHook(hook, { event, ...data });
+            } catch {
+                // Notifications are best-effort
+            }
+        }
+    }
+
+    /**
+     * Get hooks for a given event type.
+     * @param {string} eventType
+     * @returns {Array}
+     */
+    _getHooks(eventType) {
+        if (!this.hooks || !this.hooks[eventType]) return [];
+        const hooks = this.hooks[eventType];
+        return Array.isArray(hooks) ? hooks : [hooks];
+    }
+
+    /**
+     * Execute a single hook. Supports command (shell) and function hooks.
+     *
+     * @param {object} hook - hook definition
+     * @param {object} context - execution context
+     * @returns {Promise<object|null>}
+     */
+    async _executeHook(hook, context) {
+        try {
+            if (hook.command) {
+                const env = {
+                    ...process.env,
+                    HOOK_EVENT: context.event,
+                    HOOK_TOOL: context.toolName || '',
+                    HOOK_INPUT: JSON.stringify(context.input || {}),
+                };
+                const output = execSync(hook.command, {
+                    encoding: 'utf-8',
+                    timeout: hook.timeout || 10000,
+                    env,
+                });
+                try {
+                    return JSON.parse(output.trim());
+                } catch {
+                    return { output: output.trim() };
+                }
+            }
+
+            if (typeof hook.handler === 'function') {
+                return await hook.handler(context);
+            }
+
+            return null;
+        } catch (err) {
+            if (hook.failOpen !== false) {
+                // Default: fail open (allow)
+                return null;
+            }
+            return { decision: 'deny', message: `Hook error: ${err.message}` };
+        }
+    }
+}