@ruvnet/open-claude-code 2.0.0

package/src/tools/registry.mjs

@@ -0,0 +1,114 @@
+/**
+ * Tool Registry — validateInput/call interface.
+ * Mirrors Claude Code's tool dispatch system.
+ * Registers all 25+ built-in tools.
+ */
+
+import { BashTool } from './bash.mjs';
+import { ReadTool } from './read.mjs';
+import { EditTool } from './edit.mjs';
+import { WriteTool } from './write.mjs';
+import { GlobTool } from './glob.mjs';
+import { GrepTool } from './grep.mjs';
+import { AgentTool } from './agent.mjs';
+import { WebFetchTool } from './web-fetch.mjs';
+import { WebSearchTool } from './web-search.mjs';
+import { TodoWriteTool } from './todo-write.mjs';
+import { NotebookEditTool } from './notebook-edit.mjs';
+import { MultiEditTool } from './multi-edit.mjs';
+import { LsTool } from './ls.mjs';
+import { ToolSearchTool } from './tool-search.mjs';
+import { AskUserTool } from './ask-user.mjs';
+import { EnterWorktreeTool } from './enter-worktree.mjs';
+import { ExitWorktreeTool } from './exit-worktree.mjs';
+import { SkillTool } from './skill.mjs';
+import { SendMessageTool } from './send-message.mjs';
+import { RemoteTriggerTool } from './remote-trigger.mjs';
+import { CronCreateTool } from './cron-create.mjs';
+import { CronDeleteTool } from './cron-delete.mjs';
+import { CronListTool } from './cron-list.mjs';
+import { LspTool } from './lsp.mjs';
+import { ReadMcpResourceTool } from './read-mcp-resource.mjs';
+
+const BUILTIN_TOOLS = [
+    BashTool,
+    ReadTool,
+    EditTool,
+    WriteTool,
+    GlobTool,
+    GrepTool,
+    AgentTool,
+    WebFetchTool,
+    WebSearchTool,
+    TodoWriteTool,
+    NotebookEditTool,
+    MultiEditTool,
+    LsTool,
+    ToolSearchTool,
+    AskUserTool,
+    EnterWorktreeTool,
+    ExitWorktreeTool,
+    SkillTool,
+    SendMessageTool,
+    RemoteTriggerTool,
+    CronCreateTool,
+    CronDeleteTool,
+    CronListTool,
+    LspTool,
+    ReadMcpResourceTool,
+];
+
+export function createToolRegistry() {
+    const tools = new Map();
+    for (const Tool of BUILTIN_TOOLS) {
+        tools.set(Tool.name, Tool);
+    }
+
+    const registry = {
+        list() {
+            return [...tools.values()].map(t => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.inputSchema,
+            }));
+        },
+
+        async call(name, input) {
+            const tool = tools.get(name);
+            if (!tool) throw new Error(`Unknown tool: ${name}`);
+            const errors = tool.validateInput?.(input) || [];
+            if (errors.length > 0) return `Validation error: ${errors.join(', ')}`;
+            return tool.call(input);
+        },
+
+        register(tool) {
+            tools.set(tool.name, tool);
+        },
+
+        get(name) {
+            return tools.get(name);
+        },
+
+        has(name) {
+            return tools.has(name);
+        },
+
+        registerMcpTools(mcpTools, callFn) {
+            ToolSearchTool._mcpTools = mcpTools;
+
+            for (const mcpTool of mcpTools) {
+                const wrapper = {
+                    name: mcpTool.name,
+                    description: mcpTool.description || '',
+                    inputSchema: mcpTool.inputSchema || { type: 'object', properties: {} },
+                    validateInput() { return []; },
+                    async call(input) { return callFn(mcpTool.name, input); },
+                };
+                tools.set(mcpTool.name, wrapper);
+            }
+        },
+    };
+
+    ToolSearchTool._registry = registry;
+    return registry;
+}

package/src/tools/remote-trigger.mjs

@@ -0,0 +1,84 @@
+/**
+ * RemoteTrigger Tool — trigger remote execution of a task.
+ *
+ * Sends a task to a remote agent endpoint for execution.
+ * Used for distributed agent workflows and scheduled tasks.
+ */
+
+export const RemoteTriggerTool = {
+    name: 'RemoteTrigger',
+    description: 'Trigger remote execution of a task on a remote agent.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            endpoint: {
+                type: 'string',
+                description: 'Remote agent endpoint URL',
+            },
+            task: {
+                type: 'string',
+                description: 'Task description or prompt to execute remotely',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 300000)',
+            },
+            async: {
+                type: 'boolean',
+                description: 'Fire-and-forget mode (default: false)',
+            },
+        },
+        required: ['task'],
+    },
+
+    validateInput(input) {
+        return input.task ? [] : ['task is required'];
+    },
+
+    async call(input) {
+        const endpoint = input.endpoint || process.env.REMOTE_AGENT_URL;
+        if (!endpoint) {
+            return 'No remote endpoint configured. Set endpoint parameter or REMOTE_AGENT_URL env var.';
+        }
+
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(
+                () => controller.abort(),
+                input.timeout || 300000
+            );
+
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(process.env.REMOTE_AGENT_TOKEN && {
+                        Authorization: `Bearer ${process.env.REMOTE_AGENT_TOKEN}`,
+                    }),
+                },
+                body: JSON.stringify({
+                    task: input.task,
+                    async: input.async || false,
+                }),
+                signal: controller.signal,
+            });
+
+            clearTimeout(timeout);
+
+            if (!res.ok) {
+                return `Remote error: HTTP ${res.status} ${res.statusText}`;
+            }
+
+            if (input.async) {
+                return `Task submitted to ${endpoint} (async mode)`;
+            }
+
+            const data = await res.json();
+            return typeof data.result === 'string'
+                ? data.result
+                : JSON.stringify(data, null, 2);
+        } catch (err) {
+            return `Remote trigger error: ${err.message}`;
+        }
+    },
+};

package/src/tools/send-message.mjs

@@ -0,0 +1,64 @@
+/**
+ * SendMessage Tool — send a message to a teammate agent.
+ *
+ * Used in multi-agent (teams) mode to communicate between agents.
+ * Messages are stored in a shared message queue.
+ */
+
+const messageQueue = new Map(); // agentId -> messages[]
+
+export const SendMessageTool = {
+    name: 'SendMessage',
+    description: 'Send a message to a teammate agent in multi-agent mode.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            to: {
+                type: 'string',
+                description: 'Target agent ID or name',
+            },
+            content: {
+                type: 'string',
+                description: 'Message content to send',
+            },
+            type: {
+                type: 'string',
+                enum: ['request', 'response', 'notification', 'handoff'],
+                description: 'Message type (default: notification)',
+            },
+        },
+        required: ['to', 'content'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.to) errors.push('to is required');
+        if (!input.content) errors.push('content is required');
+        return errors;
+    },
+
+    async call(input) {
+        const msg = {
+            id: `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            from: process.env.AGENT_ID || 'main',
+            to: input.to,
+            type: input.type || 'notification',
+            content: input.content,
+            timestamp: new Date().toISOString(),
+        };
+
+        if (!messageQueue.has(input.to)) {
+            messageQueue.set(input.to, []);
+        }
+        messageQueue.get(input.to).push(msg);
+
+        return `Message sent to "${input.to}" (id: ${msg.id}, type: ${msg.type})`;
+    },
+
+    // Helper: receive messages for an agent
+    receive(agentId) {
+        const messages = messageQueue.get(agentId) || [];
+        messageQueue.set(agentId, []);
+        return messages;
+    },
+};

package/src/tools/skill.mjs

@@ -0,0 +1,52 @@
+/**
+ * Skill Tool — invoke a loaded skill by name.
+ *
+ * Skills are loaded from .claude/skills/{name}/SKILL.md and provide
+ * specialized prompts injected into the conversation.
+ */
+
+export const SkillTool = {
+    name: 'Skill',
+    description: 'Invoke a skill within the conversation. Skills provide specialized capabilities.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            skill: {
+                type: 'string',
+                description: 'The skill name to invoke (e.g., "commit", "review-pr")',
+            },
+            args: {
+                type: 'string',
+                description: 'Optional arguments for the skill',
+            },
+        },
+        required: ['skill'],
+    },
+
+    // Set by skills loader
+    _skillsLoader: null,
+
+    validateInput(input) {
+        return input.skill ? [] : ['skill name is required'];
+    },
+
+    async call(input) {
+        if (!this._skillsLoader) {
+            return 'Skills system not initialized. No skills available.';
+        }
+
+        try {
+            const skill = this._skillsLoader.get(input.skill);
+            if (!skill) {
+                const available = this._skillsLoader.list();
+                const names = available.map(s => s.name).join(', ');
+                return `Unknown skill: "${input.skill}". Available: ${names || 'none'}`;
+            }
+
+            const result = await this._skillsLoader.run(input.skill, input.args);
+            return result;
+        } catch (err) {
+            return `Skill error: ${err.message}`;
+        }
+    },
+};

package/src/tools/todo-write.mjs

@@ -0,0 +1,68 @@
+/**
+ * TodoWrite Tool — in-memory task management.
+ *
+ * Maintains a task list that the agent can use to track work items.
+ * State persists for the duration of the session.
+ */
+
+const todos = [];
+let nextId = 1;
+
+export const TodoWriteTool = {
+    name: 'TodoWrite',
+    description: 'Manage a task list. Supports add, update, complete, and list operations.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            todos: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Task ID (auto-assigned if adding)' },
+                        content: { type: 'string', description: 'Task description' },
+                        status: {
+                            type: 'string',
+                            enum: ['pending', 'in_progress', 'completed'],
+                            description: 'Task status',
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['high', 'medium', 'low'],
+                            description: 'Task priority',
+                        },
+                    },
+                    required: ['content', 'status'],
+                },
+                description: 'Array of todo items to write (replaces all todos)',
+            },
+        },
+        required: ['todos'],
+    },
+
+    validateInput(input) {
+        if (!input.todos || !Array.isArray(input.todos)) return ['todos must be an array'];
+        return [];
+    },
+
+    async call(input) {
+        // Replace entire todo list (matches Claude Code behavior)
+        todos.length = 0;
+        nextId = 1;
+
+        for (const item of input.todos) {
+            todos.push({
+                id: item.id || String(nextId++),
+                content: item.content,
+                status: item.status || 'pending',
+                priority: item.priority || 'medium',
+            });
+        }
+
+        const summary = todos.map(t =>
+            `[${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '~' : ' '}] ${t.id}. ${t.content} (${t.priority})`
+        ).join('\n');
+
+        return `Updated ${todos.length} todos:\n${summary}`;
+    },
+};

package/src/tools/tool-search.mjs

@@ -0,0 +1,77 @@
+/**
+ * ToolSearch Tool — deferred tool loading / search.
+ *
+ * Allows the agent to discover and load tools that are not
+ * in the default set. Supports searching MCP servers and
+ * deferred tool definitions.
+ */
+
+export const ToolSearchTool = {
+    name: 'ToolSearch',
+    description: 'Search for and load deferred tools by name or keyword.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Tool name or search keywords',
+            },
+            max_results: {
+                type: 'number',
+                description: 'Maximum results to return (default: 5)',
+            },
+        },
+        required: ['query'],
+    },
+
+    // Will be set by the registry when MCP tools are available
+    _mcpTools: [],
+    _registry: null,
+
+    validateInput(input) {
+        return input.query ? [] : ['query is required'];
+    },
+
+    async call(input) {
+        const query = input.query.toLowerCase();
+        const maxResults = input.max_results || 5;
+        const matches = [];
+
+        // Search MCP tools
+        for (const tool of this._mcpTools) {
+            const name = (tool.name || '').toLowerCase();
+            const desc = (tool.description || '').toLowerCase();
+            if (name.includes(query) || desc.includes(query)) {
+                matches.push({
+                    name: tool.name,
+                    description: tool.description,
+                    source: 'mcp',
+                });
+            }
+        }
+
+        // Search registry tools
+        if (this._registry) {
+            for (const tool of this._registry.list()) {
+                const name = (tool.name || '').toLowerCase();
+                const desc = (tool.description || '').toLowerCase();
+                if (name.includes(query) || desc.includes(query)) {
+                    matches.push({
+                        name: tool.name,
+                        description: tool.description,
+                        source: 'builtin',
+                    });
+                }
+            }
+        }
+
+        if (matches.length === 0) {
+            return `No tools found matching "${input.query}"`;
+        }
+
+        const limited = matches.slice(0, maxResults);
+        return limited.map(m =>
+            `[${m.source}] ${m.name}: ${m.description}`
+        ).join('\n');
+    },
+};

package/src/tools/web-fetch.mjs

@@ -0,0 +1,65 @@
+/**
+ * Web Fetch Tool — fetch URL content using built-in Node.js fetch.
+ */
+
+export const WebFetchTool = {
+    name: 'WebFetch',
+    description: 'Fetch content from a URL. Returns the response body as text.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'The URL to fetch' },
+            headers: {
+                type: 'object',
+                description: 'Optional HTTP headers',
+            },
+            max_length: {
+                type: 'number',
+                description: 'Max response length in characters (default: 50000)',
+            },
+        },
+        required: ['url'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.url) errors.push('url is required');
+        try {
+            new URL(input.url);
+        } catch {
+            errors.push('url must be a valid URL');
+        }
+        return errors;
+    },
+
+    async call(input) {
+        const maxLength = input.max_length || 50000;
+
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30000);
+
+            const res = await fetch(input.url, {
+                headers: input.headers || {},
+                signal: controller.signal,
+                redirect: 'follow',
+            });
+
+            clearTimeout(timeout);
+
+            if (!res.ok) {
+                return `HTTP ${res.status}: ${res.statusText}`;
+            }
+
+            const contentType = res.headers.get('content-type') || '';
+            const text = await res.text();
+            const truncated = text.length > maxLength
+                ? text.slice(0, maxLength) + `\n...[truncated at ${maxLength} chars]`
+                : text;
+
+            return `Content-Type: ${contentType}\nLength: ${text.length}\n\n${truncated}`;
+        } catch (err) {
+            return `Fetch error: ${err.message}`;
+        }
+    },
+};

package/src/tools/web-search.mjs

@@ -0,0 +1,89 @@
+/**
+ * Web Search Tool — search the web via configurable API backends.
+ *
+ * Supports:
+ * - Brave Search API (BRAVE_API_KEY)
+ * - SearXNG (self-hosted, SEARXNG_URL)
+ * - Fallback: returns instructions to use web-fetch instead
+ */
+
+export const WebSearchTool = {
+    name: 'WebSearch',
+    description: 'Search the web for information. Requires BRAVE_API_KEY or SEARXNG_URL.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            limit: { type: 'number', description: 'Max results (default: 5)' },
+        },
+        required: ['query'],
+    },
+
+    validateInput(input) {
+        return input.query ? [] : ['query is required'];
+    },
+
+    async call(input) {
+        const limit = input.limit || 5;
+
+        // Try Brave Search API
+        const braveKey = process.env.BRAVE_API_KEY;
+        if (braveKey) {
+            return searchBrave(input.query, limit, braveKey);
+        }
+
+        // Try SearXNG
+        const searxUrl = process.env.SEARXNG_URL;
+        if (searxUrl) {
+            return searchSearxng(input.query, limit, searxUrl);
+        }
+
+        return 'No search API configured. Set BRAVE_API_KEY or SEARXNG_URL environment variable. ' +
+            'Alternatively, use the WebFetch tool to fetch specific URLs directly.';
+    },
+};
+
+async function searchBrave(query, limit, apiKey) {
+    try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${limit}`;
+        const res = await fetch(url, {
+            headers: {
+                'Accept': 'application/json',
+                'X-Subscription-Token': apiKey,
+            },
+        });
+
+        if (!res.ok) return `Brave API error: ${res.status}`;
+
+        const data = await res.json();
+        const results = (data.web?.results || []).slice(0, limit);
+
+        if (results.length === 0) return 'No results found.';
+
+        return results.map((r, i) =>
+            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.description || ''}`
+        ).join('\n\n');
+    } catch (err) {
+        return `Search error: ${err.message}`;
+    }
+}
+
+async function searchSearxng(query, limit, baseUrl) {
+    try {
+        const url = `${baseUrl}/search?q=${encodeURIComponent(query)}&format=json&categories=general`;
+        const res = await fetch(url);
+
+        if (!res.ok) return `SearXNG error: ${res.status}`;
+
+        const data = await res.json();
+        const results = (data.results || []).slice(0, limit);
+
+        if (results.length === 0) return 'No results found.';
+
+        return results.map((r, i) =>
+            `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.content || ''}`
+        ).join('\n\n');
+    } catch (err) {
+        return `Search error: ${err.message}`;
+    }
+}

package/src/tools/write.mjs

@@ -0,0 +1,55 @@
+/**
+ * Write Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Creates parent directories if needed
+ * - Requires Read first for existing file overwrites
+ * - No README creation unless explicitly asked
+ */
+import fs from 'fs';
+import path from 'path';
+import { hasBeenRead, markRead } from './read.mjs';
+
+export const WriteTool = {
+    name: 'Write',
+    description: 'Write content to a file. Creates parent dirs if needed.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Absolute path to the file' },
+            content: { type: 'string', description: 'The content to write' },
+        },
+        required: ['file_path', 'content'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.file_path) errors.push('file_path required');
+        return errors;
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+
+        // Check if file already exists — require Read first for overwrites
+        if (fs.existsSync(filePath)) {
+            if (!hasBeenRead(filePath)) {
+                return `Error: File ${filePath} already exists. You must Read it first before overwriting.`;
+            }
+        }
+
+        // Create parent directory if it doesn't exist
+        const dir = path.dirname(filePath);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+        } catch (e) {
+            return `Error creating directory ${dir}: ${e.message}`;
+        }
+
+        try {
+            fs.writeFileSync(filePath, input.content);
+            markRead(filePath); // Mark as read after writing
+            return `File written: ${filePath}`;
+        } catch (e) {
+            return `Error writing file: ${e.message}`;
+        }
+    },
+};