@ruvnet/open-claude-code 2.0.0

package/src/tools/grep.mjs

@@ -0,0 +1,127 @@
+/**
+ * Grep Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Case insensitive (-i)
+ * - Line numbers (-n, default true for content mode)
+ * - Context lines (-A, -B, -C)
+ * - output_mode: content, files_with_matches, count
+ * - glob filter and type filter
+ * - head_limit (default 250)
+ * - multiline mode
+ */
+import { execSync } from 'child_process';
+import path from 'path';
+
+export const GrepTool = {
+    name: 'Grep',
+    description: 'Search file contents with regex (powered by ripgrep or grep).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Regex pattern to search for' },
+            path: { type: 'string', description: 'File or directory to search in' },
+            '-i': { type: 'boolean', description: 'Case insensitive' },
+            '-n': { type: 'boolean', description: 'Show line numbers (default true)' },
+            '-A': { type: 'number', description: 'Lines after match' },
+            '-B': { type: 'number', description: 'Lines before match' },
+            '-C': { type: 'number', description: 'Context lines (before and after)' },
+            context: { type: 'number', description: 'Alias for -C' },
+            output_mode: {
+                type: 'string',
+                enum: ['content', 'files_with_matches', 'count'],
+                description: 'Output mode (default: files_with_matches)',
+            },
+            glob: { type: 'string', description: 'Glob pattern to filter files' },
+            type: { type: 'string', description: 'File type filter (e.g. js, py)' },
+            head_limit: { type: 'number', description: 'Max output lines (default 250)' },
+            multiline: { type: 'boolean', description: 'Enable multiline matching' },
+        },
+        required: ['pattern'],
+    },
+    validateInput(input) { return input.pattern ? [] : ['pattern required']; },
+    async call(input) {
+        try {
+            const dir = path.resolve(input.path || '.');
+            const mode = input.output_mode || 'files_with_matches';
+            const limit = input.head_limit ?? 250;
+
+            // Build grep command — try rg first, fall back to grep
+            const args = [];
+            const useRg = hasRipgrep();
+
+            if (useRg) {
+                args.push('rg');
+                if (input['-i']) args.push('-i');
+                if (input.multiline) args.push('-U', '--multiline-dotall');
+
+                if (mode === 'files_with_matches') {
+                    args.push('-l');
+                } else if (mode === 'count') {
+                    args.push('-c');
+                } else {
+                    // content mode
+                    const showLineNumbers = input['-n'] !== false;
+                    if (showLineNumbers) args.push('-n');
+                }
+
+                const ctx = input['-C'] || input.context;
+                if (ctx && mode === 'content') args.push('-C', String(ctx));
+                if (input['-A'] && mode === 'content') args.push('-A', String(input['-A']));
+                if (input['-B'] && mode === 'content') args.push('-B', String(input['-B']));
+
+                if (input.glob) args.push('--glob', input.glob);
+                if (input.type) args.push('--type', input.type);
+
+                args.push('--', input.pattern, dir);
+            } else {
+                args.push('grep', '-r');
+                if (input['-i']) args.push('-i');
+
+                if (mode === 'files_with_matches') {
+                    args.push('-l');
+                } else if (mode === 'count') {
+                    args.push('-c');
+                } else {
+                    if (input['-n'] !== false) args.push('-n');
+                }
+
+                const ctx = input['-C'] || input.context;
+                if (ctx && mode === 'content') args.push('-C', String(ctx));
+                if (input['-A'] && mode === 'content') args.push('-A', String(input['-A']));
+                if (input['-B'] && mode === 'content') args.push('-B', String(input['-B']));
+
+                if (input.glob) args.push('--include', input.glob);
+
+                args.push('--', input.pattern, dir);
+            }
+
+            // Apply head_limit
+            const cmd = limit > 0
+                ? `${args.join(' ')} 2>/dev/null | head -${limit}`
+                : `${args.join(' ')} 2>/dev/null`;
+
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 30000,
+            });
+
+            return result.trim() || 'No matches found.';
+        } catch {
+            return 'No matches found.';
+        }
+    },
+};
+
+let _hasRg = null;
+function hasRipgrep() {
+    if (_hasRg !== null) return _hasRg;
+    try {
+        execSync('which rg', { encoding: 'utf-8', timeout: 5000 });
+        _hasRg = true;
+    } catch {
+        _hasRg = false;
+    }
+    return _hasRg;
+}

package/src/tools/ls.mjs

@@ -0,0 +1,58 @@
+/**
+ * LS Tool — directory listing with metadata.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export const LsTool = {
+    name: 'LS',
+    description: 'List directory contents with file sizes and types.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path to list (default: cwd)' },
+            all: { type: 'boolean', description: 'Include hidden files (default: false)' },
+        },
+        required: [],
+    },
+
+    validateInput() { return []; },
+
+    async call(input) {
+        const dirPath = path.resolve(input.path || '.');
+
+        try {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+            const results = [];
+
+            for (const entry of entries) {
+                if (!input.all && entry.name.startsWith('.')) continue;
+
+                const fullPath = path.join(dirPath, entry.name);
+                let size = '';
+                try {
+                    const stat = fs.statSync(fullPath);
+                    size = entry.isDirectory() ? '' : formatSize(stat.size);
+                } catch {
+                    size = '?';
+                }
+
+                const type = entry.isDirectory() ? 'd' : entry.isSymbolicLink() ? 'l' : '-';
+                results.push(`${type} ${size.padStart(8)} ${entry.name}${entry.isDirectory() ? '/' : ''}`);
+            }
+
+            if (results.length === 0) return 'Empty directory';
+            return `${dirPath}:\n${results.join('\n')}`;
+        } catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};
+
+function formatSize(bytes) {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}K`;
+    if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}

package/src/tools/lsp.mjs

@@ -0,0 +1,115 @@
+/**
+ * LSP Tool — Language Server Protocol integration stub.
+ *
+ * Provides a tool interface for language server features:
+ * - diagnostics (errors/warnings)
+ * - completions
+ * - hover information
+ * - go-to-definition
+ * - references
+ *
+ * This is a stub implementation. Full LSP would spawn an actual language
+ * server process and communicate via JSON-RPC.
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+
+export const LspTool = {
+    name: 'LSP',
+    description: 'Query language server for diagnostics, completions, hover, and definitions.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['diagnostics', 'completions', 'hover', 'definition', 'references'],
+                description: 'LSP action to perform',
+            },
+            file: {
+                type: 'string',
+                description: 'File path to query',
+            },
+            line: {
+                type: 'number',
+                description: 'Line number (0-based)',
+            },
+            character: {
+                type: 'number',
+                description: 'Character position (0-based)',
+            },
+            language: {
+                type: 'string',
+                description: 'Language ID (e.g., "typescript", "python")',
+            },
+        },
+        required: ['action', 'file'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.action) errors.push('action is required');
+        if (!input.file) errors.push('file is required');
+        return errors;
+    },
+
+    async call(input) {
+        const filePath = path.resolve(input.file);
+        const action = input.action;
+
+        switch (action) {
+            case 'diagnostics':
+                return getDiagnostics(filePath, input.language);
+            case 'completions':
+                return `[LSP stub] Completions at ${filePath}:${input.line}:${input.character} not yet implemented.`;
+            case 'hover':
+                return `[LSP stub] Hover at ${filePath}:${input.line}:${input.character} not yet implemented.`;
+            case 'definition':
+                return `[LSP stub] Go-to-definition at ${filePath}:${input.line}:${input.character} not yet implemented.`;
+            case 'references':
+                return `[LSP stub] Find references at ${filePath}:${input.line}:${input.character} not yet implemented.`;
+            default:
+                return `Unknown LSP action: ${action}`;
+        }
+    },
+};
+
+function getDiagnostics(filePath, language) {
+    const ext = path.extname(filePath);
+    const lang = language || extToLanguage(ext);
+
+    try {
+        switch (lang) {
+            case 'typescript':
+            case 'javascript': {
+                const result = execSync(
+                    `npx tsc --noEmit --pretty false "${filePath}" 2>&1 || true`,
+                    { encoding: 'utf-8', timeout: 15000 }
+                );
+                return result.trim() || 'No diagnostics.';
+            }
+            case 'python': {
+                const result = execSync(
+                    `python3 -m py_compile "${filePath}" 2>&1 || true`,
+                    { encoding: 'utf-8', timeout: 10000 }
+                );
+                return result.trim() || 'No diagnostics.';
+            }
+            default:
+                return `[LSP stub] No diagnostic provider for language: ${lang}`;
+        }
+    } catch (err) {
+        return `Diagnostics error: ${err.message}`;
+    }
+}
+
+function extToLanguage(ext) {
+    const map = {
+        '.ts': 'typescript', '.tsx': 'typescript',
+        '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript',
+        '.py': 'python',
+        '.rs': 'rust', '.go': 'go', '.java': 'java',
+        '.rb': 'ruby', '.php': 'php', '.cs': 'csharp',
+    };
+    return map[ext] || 'unknown';
+}

package/src/tools/multi-edit.mjs

@@ -0,0 +1,94 @@
+/**
+ * MultiEdit Tool — apply multiple edits to one or more files atomically.
+ *
+ * Each edit is an { file_path, old_string, new_string } triple.
+ * All edits are validated before any are applied.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export const MultiEditTool = {
+    name: 'MultiEdit',
+    description: 'Apply multiple file edits in a single operation. All edits are validated first.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            edits: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        file_path: { type: 'string' },
+                        old_string: { type: 'string' },
+                        new_string: { type: 'string' },
+                    },
+                    required: ['file_path', 'old_string', 'new_string'],
+                },
+                description: 'Array of edits to apply',
+            },
+        },
+        required: ['edits'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.edits || !Array.isArray(input.edits)) {
+            errors.push('edits must be an array');
+            return errors;
+        }
+        for (let i = 0; i < input.edits.length; i++) {
+            const e = input.edits[i];
+            if (!e.file_path) errors.push(`edit[${i}]: file_path required`);
+            if (!e.old_string) errors.push(`edit[${i}]: old_string required`);
+            if (e.old_string === e.new_string) errors.push(`edit[${i}]: old_string must differ from new_string`);
+        }
+        return errors;
+    },
+
+    async call(input) {
+        // Phase 1: Validate all edits
+        const fileContents = new Map();
+        const errors = [];
+
+        for (let i = 0; i < input.edits.length; i++) {
+            const edit = input.edits[i];
+            const filePath = path.resolve(edit.file_path);
+
+            if (!fileContents.has(filePath)) {
+                try {
+                    fileContents.set(filePath, fs.readFileSync(filePath, 'utf-8'));
+                } catch (err) {
+                    errors.push(`edit[${i}]: cannot read ${filePath}: ${err.message}`);
+                    continue;
+                }
+            }
+
+            let content = fileContents.get(filePath);
+            if (!content.includes(edit.old_string)) {
+                errors.push(`edit[${i}]: old_string not found in ${edit.file_path}`);
+            }
+        }
+
+        if (errors.length > 0) {
+            return `Validation failed:\n${errors.join('\n')}`;
+        }
+
+        // Phase 2: Apply all edits
+        const applied = [];
+        for (const edit of input.edits) {
+            const filePath = path.resolve(edit.file_path);
+            let content = fileContents.get(filePath);
+            content = content.replace(edit.old_string, edit.new_string);
+            fileContents.set(filePath, content);
+        }
+
+        // Phase 3: Write all files
+        for (const [filePath, content] of fileContents) {
+            fs.writeFileSync(filePath, content);
+            applied.push(filePath);
+        }
+
+        return `Applied ${input.edits.length} edits to ${applied.length} file(s):\n${applied.join('\n')}`;
+    },
+};

package/src/tools/notebook-edit.mjs

@@ -0,0 +1,96 @@
+/**
+ * NotebookEdit Tool — edit Jupyter notebook (.ipynb) cells.
+ *
+ * Supports operations:
+ * - insert: add a new cell at a position
+ * - replace: replace content of an existing cell
+ * - delete: remove a cell
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export const NotebookEditTool = {
+    name: 'NotebookEdit',
+    description: 'Edit Jupyter notebook cells. Supports insert, replace, and delete operations.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            notebook_path: { type: 'string', description: 'Path to the .ipynb file' },
+            operation: {
+                type: 'string',
+                enum: ['insert', 'replace', 'delete'],
+                description: 'Operation to perform',
+            },
+            cell_index: { type: 'number', description: 'Cell index (0-based)' },
+            cell_type: {
+                type: 'string',
+                enum: ['code', 'markdown', 'raw'],
+                description: 'Cell type (for insert/replace)',
+            },
+            source: { type: 'string', description: 'Cell content (for insert/replace)' },
+        },
+        required: ['notebook_path', 'operation', 'cell_index'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.notebook_path) errors.push('notebook_path required');
+        if (!['insert', 'replace', 'delete'].includes(input.operation)) {
+            errors.push('operation must be insert, replace, or delete');
+        }
+        if (typeof input.cell_index !== 'number') errors.push('cell_index must be a number');
+        if (input.operation !== 'delete' && !input.source) errors.push('source required for insert/replace');
+        return errors;
+    },
+
+    async call(input) {
+        const filePath = path.resolve(input.notebook_path);
+
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const notebook = JSON.parse(raw);
+
+            if (!notebook.cells || !Array.isArray(notebook.cells)) {
+                return 'Error: invalid notebook format (no cells array)';
+            }
+
+            const cellType = input.cell_type || 'code';
+            const sourceLines = (input.source || '').split('\n').map(l => l + '\n');
+
+            switch (input.operation) {
+                case 'insert': {
+                    const newCell = {
+                        cell_type: cellType,
+                        metadata: {},
+                        source: sourceLines,
+                        ...(cellType === 'code' ? { outputs: [], execution_count: null } : {}),
+                    };
+                    const idx = Math.min(input.cell_index, notebook.cells.length);
+                    notebook.cells.splice(idx, 0, newCell);
+                    break;
+                }
+                case 'replace': {
+                    if (input.cell_index >= notebook.cells.length) {
+                        return `Error: cell_index ${input.cell_index} out of range (${notebook.cells.length} cells)`;
+                    }
+                    notebook.cells[input.cell_index].source = sourceLines;
+                    if (cellType) notebook.cells[input.cell_index].cell_type = cellType;
+                    break;
+                }
+                case 'delete': {
+                    if (input.cell_index >= notebook.cells.length) {
+                        return `Error: cell_index ${input.cell_index} out of range (${notebook.cells.length} cells)`;
+                    }
+                    notebook.cells.splice(input.cell_index, 1);
+                    break;
+                }
+            }
+
+            fs.writeFileSync(filePath, JSON.stringify(notebook, null, 1));
+            return `Notebook updated: ${input.operation} at cell ${input.cell_index} (${notebook.cells.length} cells total)`;
+        } catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+};

package/src/tools/read-mcp-resource.mjs

@@ -0,0 +1,57 @@
+/**
+ * ReadMcpResource Tool — read a resource from an MCP server.
+ *
+ * MCP resources are identified by URI and can contain text, JSON,
+ * or binary data. This tool reads text/JSON resources.
+ */
+
+export const ReadMcpResourceTool = {
+    name: 'ReadMcpResource',
+    description: 'Read a resource from an MCP server by URI.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            uri: {
+                type: 'string',
+                description: 'Resource URI (e.g., "file:///path" or "mcp://server/resource")',
+            },
+            server: {
+                type: 'string',
+                description: 'MCP server name (if URI does not specify)',
+            },
+        },
+        required: ['uri'],
+    },
+
+    // Set by the MCP integration layer
+    _mcpClients: null,
+
+    validateInput(input) {
+        return input.uri ? [] : ['uri is required'];
+    },
+
+    async call(input) {
+        if (!this._mcpClients || this._mcpClients.length === 0) {
+            return 'No MCP servers connected. Configure MCP servers in settings.';
+        }
+
+        for (const client of this._mcpClients) {
+            try {
+                const result = await client.readResource(input.uri);
+                if (result) {
+                    if (typeof result === 'string') return result;
+                    if (result.contents && Array.isArray(result.contents)) {
+                        return result.contents
+                            .map(c => c.text || JSON.stringify(c))
+                            .join('\n');
+                    }
+                    return JSON.stringify(result, null, 2);
+                }
+            } catch {
+                // Try next client
+            }
+        }
+
+        return `Resource not found: ${input.uri}`;
+    },
+};

package/src/tools/read.mjs

@@ -0,0 +1,138 @@
+/**
+ * Read Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - pages parameter for PDF files
+ * - Binary file detection
+ * - Default 2000 line limit
+ * - Line number prefix (cat -n format)
+ * - Graceful file not found handling
+ * - Tracks read files for Edit/Write verification
+ */
+import fs from 'fs';
+import path from 'path';
+
+const DEFAULT_LIMIT = 2000;
+
+// Track which files have been read (used by Edit and Write tools)
+const readFiles = new Set();
+
+export function hasBeenRead(filePath) {
+    return readFiles.has(path.resolve(filePath));
+}
+
+export function markRead(filePath) {
+    readFiles.add(path.resolve(filePath));
+}
+
+// Binary detection: check for null bytes in first 8KB
+function isBinary(buffer) {
+    const len = Math.min(buffer.length, 8192);
+    for (let i = 0; i < len; i++) {
+        if (buffer[i] === 0) return true;
+    }
+    return false;
+}
+
+export const ReadTool = {
+    name: 'Read',
+    description: 'Read a file from the local filesystem.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Absolute path to the file' },
+            offset: { type: 'number', description: 'Line number to start reading from (0-based)' },
+            limit: { type: 'number', description: 'Number of lines to read (default 2000)' },
+            pages: { type: 'string', description: 'Page range for PDF files (e.g. "1-5")' },
+        },
+        required: ['file_path'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.file_path) errors.push('file_path is required');
+        return errors;
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+
+        // Check existence
+        if (!fs.existsSync(filePath)) {
+            return `Error: File not found: ${filePath}`;
+        }
+
+        // Check if directory
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            return `Error: ${filePath} is a directory, not a file. Use Bash with ls to list directory contents.`;
+        }
+
+        // PDF handling
+        if (filePath.endsWith('.pdf')) {
+            return readPdf(filePath, input.pages);
+        }
+
+        // Binary detection
+        try {
+            const fd = fs.openSync(filePath, 'r');
+            const buf = Buffer.alloc(8192);
+            const bytesRead = fs.readSync(fd, buf, 0, 8192, 0);
+            fs.closeSync(fd);
+            if (isBinary(buf.subarray(0, bytesRead))) {
+                return `Error: ${filePath} appears to be a binary file. Cannot display binary content.`;
+            }
+        } catch (e) {
+            return `Error: ${e.message}`;
+        }
+
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n');
+            const start = input.offset || 0;
+            const limit = input.limit || DEFAULT_LIMIT;
+            const end = Math.min(start + limit, lines.length);
+
+            // Track as read
+            readFiles.add(filePath);
+
+            // Handle empty files
+            if (content === '' || (content.length === 0)) {
+                return '[File exists but is empty]';
+            }
+
+            const output = lines
+                .slice(start, end)
+                .map((l, i) => `${start + i + 1}\t${l}`)
+                .join('\n');
+
+            if (end < lines.length) {
+                return output + `\n\n[File has ${lines.length} lines total. Showing lines ${start + 1}-${end}. Use offset/limit for more.]`;
+            }
+
+            return output;
+        } catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};
+
+function readPdf(filePath, pages) {
+    // PDF reading requires external tools; provide a best-effort
+    // text extraction using a simple approach
+    try {
+        const { execSync } = await_import_child_process();
+        const pageArg = pages ? `-f ${pages.split('-')[0]} -l ${pages.split('-').pop()}` : '-f 1 -l 20';
+        const text = execSync(`pdftotext ${pageArg} "${filePath}" - 2>/dev/null`, {
+            encoding: 'utf-8',
+            timeout: 30000,
+            maxBuffer: 1024 * 1024,
+        });
+        return text || `[PDF file at ${filePath} — could not extract text. Use a PDF viewer.]`;
+    } catch {
+        return `[PDF file at ${filePath} — pdftotext not available. Install poppler-utils for PDF support.]`;
+    }
+}
+
+// Lazy import helper
+function await_import_child_process() {
+    return require('child_process');
+}