neuro-cli 4.1.0

package/dist/tools/extended.d.ts

@@ -0,0 +1,6 @@
+import { ToolExecutor } from '../tools/registry.js';
+export declare const todoTool: ToolExecutor;
+export declare const askUserTool: ToolExecutor;
+export declare const monitorTool: ToolExecutor;
+export declare const extendedTools: ToolExecutor[];
+//# sourceMappingURL=extended.d.ts.map

package/dist/tools/extended.js

@@ -0,0 +1,191 @@
+// ============================================================
+// NeuroCLI - Extended Tools: Todo, AskUser, Monitor, Sandbox
+// ============================================================
+import { spawn } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+// ---- Todo List Tool ----
+const todoDef = {
+    name: 'todowrite',
+    description: 'Create and manage a todo list for the current session. Track tasks, priorities, and completion status.',
+    parameters: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: "create", "update", "list", "delete"', enum: ['create', 'update', 'list', 'delete'] },
+            id: { type: 'string', description: 'Todo item ID (for update/delete)' },
+            content: { type: 'string', description: 'Todo item content/description' },
+            status: { type: 'string', description: 'Status: "pending", "in_progress", "completed"', enum: ['pending', 'in_progress', 'completed'] },
+            priority: { type: 'string', description: 'Priority: "high", "medium", "low"', enum: ['high', 'medium', 'low'] },
+        },
+        required: ['action'],
+    },
+};
+const TODO_FILE = join(homedir(), '.neuro', 'todos.json');
+function loadTodos() {
+    if (!existsSync(TODO_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(TODO_FILE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveTodos(todos) {
+    mkdirSync(join(homedir(), '.neuro'), { recursive: true });
+    writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2), 'utf-8');
+}
+export const todoTool = {
+    name: 'todowrite',
+    definition: todoDef,
+    risk: 'low',
+    async execute(args) {
+        const todos = loadTodos();
+        const action = args.action;
+        switch (action) {
+            case 'create': {
+                const item = {
+                    id: `todo_${Date.now()}`,
+                    content: args.content || 'Untitled task',
+                    status: 'pending',
+                    priority: args.priority || 'medium',
+                    createdAt: Date.now(),
+                };
+                todos.push(item);
+                saveTodos(todos);
+                return `Created todo: [${item.priority}] ${item.content} (${item.id})`;
+            }
+            case 'update': {
+                const id = args.id;
+                const item = todos.find(t => t.id === id);
+                if (!item)
+                    return `Todo not found: ${id}`;
+                if (args.content)
+                    item.content = args.content;
+                if (args.status)
+                    item.status = args.status;
+                if (args.priority)
+                    item.priority = args.priority;
+                saveTodos(todos);
+                return `Updated todo ${id}: [${item.priority}] ${item.content} - ${item.status}`;
+            }
+            case 'list': {
+                if (todos.length === 0)
+                    return 'No todos. Use action="create" to add one.';
+                return todos.map(t => `${t.status === 'completed' ? '✅' : t.status === 'in_progress' ? '🔄' : '⬜'} [${t.priority}] ${t.content} (${t.id})`).join('\n');
+            }
+            case 'delete': {
+                const id = args.id;
+                const idx = todos.findIndex(t => t.id === id);
+                if (idx === -1)
+                    return `Todo not found: ${id}`;
+                const removed = todos.splice(idx, 1)[0];
+                saveTodos(todos);
+                return `Deleted todo: ${removed.content}`;
+            }
+            default:
+                return `Unknown action: ${action}. Use create, update, list, or delete.`;
+        }
+    },
+};
+// ---- AskUserQuestion Tool ----
+const askUserDef = {
+    name: 'ask_user',
+    description: 'Ask the user a question with multiple-choice options. Use when you need clarification or decisions.',
+    parameters: {
+        type: 'object',
+        properties: {
+            question: { type: 'string', description: 'The question to ask the user' },
+            options: { type: 'string', description: 'Comma-separated list of options' },
+            default: { type: 'string', description: 'Default option if user does not respond' },
+        },
+        required: ['question'],
+    },
+};
+export const askUserTool = {
+    name: 'ask_user',
+    definition: askUserDef,
+    risk: 'low',
+    async execute(args) {
+        const question = args.question;
+        const options = args.options?.split(',').map(o => o.trim()) || [];
+        const defaultOption = args.default;
+        // In non-interactive mode, use default
+        if (defaultOption) {
+            return `User selected (default): ${defaultOption}`;
+        }
+        // In interactive mode, this would prompt the user
+        // For now, return the question with options
+        let prompt = `❓ ${question}`;
+        if (options.length > 0) {
+            prompt += `\nOptions: ${options.map((o, i) => `${i + 1}. ${o}`).join(', ')}`;
+        }
+        prompt += '\n\n[Waiting for user input - using auto-approve in non-interactive mode]';
+        return prompt;
+    },
+};
+// ---- Monitor Tool ----
+const monitorDef = {
+    name: 'monitor',
+    description: 'Run a command in the background and monitor its output. Returns each output line as it becomes available.',
+    parameters: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Command to run in background' },
+            duration: { type: 'number', description: 'Maximum monitoring duration in seconds (default: 60)' },
+        },
+        required: ['command'],
+    },
+};
+const activeMonitors = new Map();
+export const monitorTool = {
+    name: 'monitor',
+    definition: monitorDef,
+    risk: 'medium',
+    async execute(args, context) {
+        const command = args.command;
+        const duration = (args.duration || 60) * 1000;
+        try {
+            const child = spawn('sh', ['-c', command], {
+                cwd: context.workingDirectory,
+                env: { ...process.env, FORCE_COLOR: '0' },
+            });
+            const monitorId = `mon_${Date.now()}`;
+            activeMonitors.set(monitorId, child);
+            const outputLines = [];
+            let timedOut = false;
+            const timeout = setTimeout(() => {
+                timedOut = true;
+                child.kill();
+            }, duration);
+            return new Promise((resolve) => {
+                child.stdout?.on('data', (data) => {
+                    const lines = data.toString().split('\n').filter(l => l.trim());
+                    outputLines.push(...lines.slice(0, 50)); // Limit lines
+                });
+                child.stderr?.on('data', (data) => {
+                    const lines = data.toString().split('\n').filter(l => l.trim());
+                    outputLines.push(...lines.slice(0, 20));
+                });
+                child.on('close', (code) => {
+                    clearTimeout(timeout);
+                    activeMonitors.delete(monitorId);
+                    const status = timedOut ? 'TIMEOUT' : `exit code ${code}`;
+                    const output = outputLines.join('\n').slice(0, 10000);
+                    resolve(`Monitor [${monitorId}] ${status}\nOutput:\n${output || '(no output)'}`);
+                });
+            });
+        }
+        catch (error) {
+            return `Monitor error: ${error}`;
+        }
+    },
+};
+// ---- All Extended Tools ----
+export const extendedTools = [
+    todoTool,
+    askUserTool,
+    monitorTool,
+];
+//# sourceMappingURL=extended.js.map

package/dist/tools/file.d.ts

@@ -0,0 +1,10 @@
+import { ToolExecutor } from './registry.js';
+export declare const readFileTool: ToolExecutor;
+export declare const writeFileTool: ToolExecutor;
+export declare const editFileTool: ToolExecutor;
+export declare const deleteFileTool: ToolExecutor;
+export declare const listDirectoryTool: ToolExecutor;
+export declare const searchFilesTool: ToolExecutor;
+export declare const applyDiffTool: ToolExecutor;
+export declare const fileTools: ToolExecutor[];
+//# sourceMappingURL=file.d.ts.map

package/dist/tools/file.js

@@ -0,0 +1,382 @@
+// ============================================================
+// NeuroCLI - File Operation Tools
+// read, write, edit, delete, list, search
+// ============================================================
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, statSync, readdirSync } from 'fs';
+import { join, relative, extname } from 'path';
+import { execSync } from 'child_process';
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB
+const MAX_OUTPUT_LENGTH = 50000;
+function truncateOutput(output, maxLength = MAX_OUTPUT_LENGTH) {
+    if (output.length <= maxLength)
+        return output;
+    const half = Math.floor(maxLength / 2);
+    return output.slice(0, half) + '\n\n... [truncated] ...\n\n' + output.slice(-half);
+}
+// ---- Read File ----
+const readFileDef = {
+    name: 'read_file',
+    description: 'Read the contents of a file. Returns the file content with line numbers. Supports reading specific line ranges.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file (relative to working directory or absolute)' },
+            start_line: { type: 'number', description: 'Starting line number (1-based, optional)' },
+            end_line: { type: 'number', description: 'Ending line number (inclusive, optional)' },
+        },
+        required: ['path'],
+    },
+};
+export const readFileTool = {
+    name: 'read_file',
+    definition: readFileDef,
+    risk: 'low',
+    async execute(args, context) {
+        const filePath = join(context.workingDirectory, args.path);
+        if (!existsSync(filePath))
+            return `Error: File not found: ${args.path}`;
+        const stat = statSync(filePath);
+        if (stat.isDirectory())
+            return `Error: Path is a directory, not a file: ${args.path}`;
+        if (stat.size > MAX_FILE_SIZE)
+            return `Error: File too large (${(stat.size / 1024).toFixed(1)}KB). Use search_files for large files.`;
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const start = args.start_line || 1;
+        const end = args.end_line || lines.length;
+        const selected = lines.slice(start - 1, end);
+        const numbered = selected.map((line, i) => {
+            const lineNum = (start + i).toString().padStart(5, ' ');
+            return `${lineNum}│ ${line}`;
+        }).join('\n');
+        return truncateOutput(`File: ${args.path} (${lines.length} lines)\n${numbered}`);
+    },
+};
+// ---- Write File ----
+const writeFileDef = {
+    name: 'write_file',
+    description: 'Create or overwrite a file with the given content. Creates parent directories if needed.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file (relative to working directory or absolute)' },
+            content: { type: 'string', description: 'Content to write to the file' },
+        },
+        required: ['path', 'content'],
+    },
+};
+export const writeFileTool = {
+    name: 'write_file',
+    definition: writeFileDef,
+    risk: 'high',
+    getApprovalRequest(args) {
+        return {
+            toolName: 'write_file',
+            args,
+            risk: 'high',
+            description: `Write file: ${args.path} (${(String(args.content).length / 1024).toFixed(1)}KB)`,
+        };
+    },
+    async execute(args, context) {
+        const filePath = join(context.workingDirectory, args.path);
+        const dir = join(filePath, '..');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(filePath, args.content, 'utf-8');
+        return `Successfully wrote ${String(args.content).length} bytes to ${args.path}`;
+    },
+};
+// ---- Edit File ----
+const editFileDef = {
+    name: 'edit_file',
+    description: 'Make targeted edits to an existing file by replacing specific text. Supports multiple edits in one call.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file' },
+            old_text: { type: 'string', description: 'Text to find in the file' },
+            new_text: { type: 'string', description: 'Text to replace it with' },
+        },
+        required: ['path', 'old_text', 'new_text'],
+    },
+};
+export const editFileTool = {
+    name: 'edit_file',
+    definition: editFileDef,
+    risk: 'medium',
+    getApprovalRequest(args) {
+        return {
+            toolName: 'edit_file',
+            args,
+            risk: 'medium',
+            description: `Edit file: ${args.path}`,
+        };
+    },
+    async execute(args, context) {
+        const filePath = join(context.workingDirectory, args.path);
+        if (!existsSync(filePath))
+            return `Error: File not found: ${args.path}`;
+        let content = readFileSync(filePath, 'utf-8');
+        const old_text = args.old_text;
+        const new_text = args.new_text;
+        if (!content.includes(old_text)) {
+            return `Error: Could not find the specified text in ${args.path}. The text to replace was not found exactly.`;
+        }
+        const occurrences = content.split(old_text).length - 1;
+        if (occurrences > 1) {
+            return `Error: Found ${occurrences} occurrences of the text in ${args.path}. Please provide more context to make the match unique.`;
+        }
+        content = content.replace(old_text, new_text);
+        writeFileSync(filePath, content, 'utf-8');
+        return `Successfully applied edit to ${args.path}`;
+    },
+};
+// ---- Delete File ----
+const deleteFileDef = {
+    name: 'delete_file',
+    description: 'Delete a file. Use with extreme caution.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to delete' },
+        },
+        required: ['path'],
+    },
+};
+export const deleteFileTool = {
+    name: 'delete_file',
+    definition: deleteFileDef,
+    risk: 'high',
+    getApprovalRequest(args) {
+        return {
+            toolName: 'delete_file',
+            args,
+            risk: 'high',
+            description: `DELETE file: ${args.path}`,
+        };
+    },
+    async execute(args, context) {
+        const filePath = join(context.workingDirectory, args.path);
+        if (!existsSync(filePath))
+            return `Error: File not found: ${args.path}`;
+        unlinkSync(filePath);
+        return `Successfully deleted ${args.path}`;
+    },
+};
+// ---- List Directory ----
+const listDirDef = {
+    name: 'list_directory',
+    description: 'List files and directories in a path. Shows file sizes and types.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory path (default: current working directory)' },
+            recursive: { type: 'boolean', description: 'Whether to list recursively (default: false)' },
+            max_depth: { type: 'number', description: 'Maximum depth for recursive listing (default: 3)' },
+        },
+        required: [],
+    },
+};
+export const listDirectoryTool = {
+    name: 'list_directory',
+    definition: listDirDef,
+    risk: 'low',
+    async execute(args, context) {
+        const dirPath = join(context.workingDirectory, args.path || '.');
+        if (!existsSync(dirPath))
+            return `Error: Directory not found: ${args.path}`;
+        const stat = statSync(dirPath);
+        if (!stat.isDirectory())
+            return `Error: Path is not a directory: ${args.path}`;
+        const recursive = args.recursive || false;
+        const maxDepth = args.max_depth || 3;
+        function listDir(path, prefix, depth) {
+            if (depth > maxDepth)
+                return `${prefix}... (max depth reached)`;
+            const entries = readdirSync(path, { withFileTypes: true });
+            // Sort: directories first, then files
+            const sorted = entries.sort((a, b) => {
+                if (a.isDirectory() && !b.isDirectory())
+                    return -1;
+                if (!a.isDirectory() && b.isDirectory())
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            // Skip common noise directories
+            const skipDirs = new Set(['node_modules', '.git', '__pycache__', '.next', 'dist', '.turbo', '.cache']);
+            const lines = [];
+            for (const entry of sorted) {
+                if (skipDirs.has(entry.name) && entry.isDirectory()) {
+                    lines.push(`${prefix}📁 ${entry.name}/ (skipped)`);
+                    continue;
+                }
+                const fullPath = join(path, entry.name);
+                if (entry.isDirectory()) {
+                    lines.push(`${prefix}📁 ${entry.name}/`);
+                    if (recursive) {
+                        lines.push(listDir(fullPath, `${prefix}  `, depth + 1));
+                    }
+                }
+                else {
+                    try {
+                        const size = statSync(fullPath).size;
+                        const sizeStr = size < 1024 ? `${size}B` : size < 1024 * 1024 ? `${(size / 1024).toFixed(1)}KB` : `${(size / (1024 * 1024)).toFixed(1)}MB`;
+                        const ext = extname(entry.name);
+                        const icon = getFileIcon(ext);
+                        lines.push(`${prefix}${icon} ${entry.name} (${sizeStr})`);
+                    }
+                    catch {
+                        lines.push(`${prefix}📄 ${entry.name}`);
+                    }
+                }
+            }
+            return lines.join('\n');
+        }
+        const result = listDir(dirPath, '', 0);
+        return truncateOutput(`Directory: ${args.path || '.'}\n${result}`);
+    },
+};
+// ---- Search Files (ripgrep) ----
+const searchFilesDef = {
+    name: 'search_files',
+    description: 'Search for patterns in files using ripgrep. Supports regex patterns and file type filtering.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Search pattern (supports regex)' },
+            path: { type: 'string', description: 'Directory or file to search in (default: current directory)' },
+            file_type: { type: 'string', description: 'File type filter (e.g., "ts", "py", "js")' },
+            max_results: { type: 'number', description: 'Maximum number of results (default: 50)' },
+            case_insensitive: { type: 'boolean', description: 'Case insensitive search (default: false)' },
+        },
+        required: ['pattern'],
+    },
+};
+export const searchFilesTool = {
+    name: 'search_files',
+    definition: searchFilesDef,
+    risk: 'low',
+    async execute(args, context) {
+        const pattern = args.pattern;
+        const searchPath = join(context.workingDirectory, args.path || '.');
+        const fileType = args.file_type;
+        const maxResults = args.max_results || 50;
+        const caseInsensitive = args.case_insensitive || false;
+        let cmd = 'rg';
+        cmd += ` --line-number`;
+        cmd += ` --column`;
+        cmd += ` --max-count ${maxResults}`;
+        cmd += caseInsensitive ? ' -i' : '';
+        if (fileType)
+            cmd += ` --type ${fileType}`;
+        cmd += ` --color never`;
+        cmd += ` --no-heading`;
+        cmd += ` '${pattern.replace(/'/g, "'\\''")}'`;
+        cmd += ` "${searchPath}"`;
+        try {
+            const result = execSync(cmd, {
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                cwd: context.workingDirectory,
+                timeout: 30000,
+            }).trim();
+            if (!result)
+                return `No matches found for pattern: "${pattern}"`;
+            const lines = result.split('\n').slice(0, maxResults);
+            const formatted = lines.map(line => {
+                const match = line.match(/^(.+?):(\d+):(\d+):(.*)$/);
+                if (match) {
+                    const [, file, lineNum, col, text] = match;
+                    const relPath = relative(context.workingDirectory, file);
+                    return `${relPath}:${lineNum}:${col}: ${text.trim()}`;
+                }
+                return line;
+            }).join('\n');
+            const totalLines = result.split('\n').length;
+            const suffix = totalLines > maxResults ? `\n... and ${totalLines - maxResults} more results` : '';
+            return truncateOutput(`Search results for "${pattern}":\n${formatted}${suffix}`);
+        }
+        catch (error) {
+            if (error.status === 1)
+                return `No matches found for pattern: "${pattern}"`;
+            if (error.status === 2)
+                return `Search error: ${error.message}`;
+            return `Search error: ${error.message}`;
+        }
+    },
+};
+// ---- Apply Diff ----
+const applyDiffDef = {
+    name: 'apply_diff',
+    description: 'Apply a unified diff to a file. Use for precise code modifications.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to modify' },
+            diff: { type: 'string', description: 'Unified diff to apply' },
+        },
+        required: ['path', 'diff'],
+    },
+};
+export const applyDiffTool = {
+    name: 'apply_diff',
+    definition: applyDiffDef,
+    risk: 'medium',
+    getApprovalRequest(args) {
+        return {
+            toolName: 'apply_diff',
+            args,
+            risk: 'medium',
+            description: `Apply diff to: ${args.path}`,
+        };
+    },
+    async execute(args, context) {
+        const filePath = join(context.workingDirectory, args.path);
+        if (!existsSync(filePath))
+            return `Error: File not found: ${args.path}`;
+        try {
+            // Write diff to temp file and apply with patch
+            const diffContent = args.diff;
+            const tmpDiffPath = join(context.workingDirectory, `.neuro-diff-${Date.now()}.patch`);
+            writeFileSync(tmpDiffPath, diffContent, 'utf-8');
+            const result = execSync(`patch --no-backup-if-mismatch -p0 < "${tmpDiffPath}"`, {
+                encoding: 'utf-8',
+                cwd: context.workingDirectory,
+                timeout: 10000,
+            });
+            // Clean up temp file
+            try {
+                unlinkSync(tmpDiffPath);
+            }
+            catch { }
+            return `Successfully applied diff to ${args.path}\n${result}`;
+        }
+        catch (error) {
+            return `Error applying diff: ${error.message}`;
+        }
+    },
+};
+// ---- Helper Functions ----
+function getFileIcon(ext) {
+    const icons = {
+        '.ts': '🔷', '.tsx': '⚛️', '.js': '🟨', '.jsx': '⚛️',
+        '.py': '🐍', '.rs': '🦀', '.go': '🐹', '.java': '☕',
+        '.css': '🎨', '.scss': '🎨', '.html': '🌐', '.json': '📋',
+        '.md': '📝', '.yml': '⚙️', '.yaml': '⚙️', '.toml': '⚙️',
+        '.sql': '🗃️', '.sh': '🖥️', '.bash': '🖥️', '.zsh': '🖥️',
+        '.env': '🔒', '.lock': '🔒', '.gitignore': '🚫',
+    };
+    return icons[ext] || '📄';
+}
+// Export all file tools
+export const fileTools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    deleteFileTool,
+    listDirectoryTool,
+    searchFilesTool,
+    applyDiffTool,
+];
+//# sourceMappingURL=file.js.map