protoagent 0.0.5 → 0.1.0

package/dist/tools/edit-file.js

@@ -1,181 +1,75 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { randomBytes } from 'crypto';
-import { requestFileOperationApproval } from '../utils/file-operations-approval.js';
-import { isUserCancellation } from '../utils/user-cancellation.js';
-import { logger } from '../utils/logger.js';
-// Current working directory for file operations
-const workingDirectory = process.cwd();
-// Security utilities
-function normalizePath(p) {
-    return path.normalize(p);
-}
-async function validatePath(requestedPath) {
-    const absolute = path.isAbsolute(requestedPath)
-        ? path.resolve(requestedPath)
-        : path.resolve(workingDirectory, requestedPath);
-    const normalizedRequested = normalizePath(absolute);
-    // Check if path is within working directory
-    if (!normalizedRequested.startsWith(workingDirectory)) {
-        throw new Error(`Access denied - path outside working directory: ${absolute}`);
-    }
-    // Handle symlinks by checking their real path
-    try {
-        const realPath = await fs.realpath(absolute);
-        const normalizedReal = normalizePath(realPath);
-        if (!normalizedReal.startsWith(workingDirectory)) {
-            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
-        }
-        return realPath;
-    }
-    catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        if (error.code === 'ENOENT') {
-            const parentDir = path.dirname(absolute);
-            try {
-                const realParentPath = await fs.realpath(parentDir);
-                const normalizedParent = normalizePath(realParentPath);
-                if (!normalizedParent.startsWith(workingDirectory)) {
-                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
-                }
-                return absolute;
-            }
-            catch {
-                throw new Error(`Parent directory does not exist: ${parentDir}`);
-            }
-        }
-        throw error;
-    }
-}
-export async function editFile(filePath, oldString, newString, expectedReplacements) {
-    try {
-        const validPath = await validatePath(filePath);
-        // Read current file content
-        const currentContent = await fs.readFile(validPath, 'utf-8');
-        // Check if the old string exists in the file
-        if (!currentContent.includes(oldString)) {
-            throw new Error(`Old string not found in file. Make sure the text matches exactly, including whitespace and line breaks.`);
-        }
-        // Count occurrences of the old string
-        const occurrences = (currentContent.match(new RegExp(escapeRegExp(oldString), 'g')) || []).length;
-        // If expected replacements is specified, validate it
-        if (expectedReplacements !== undefined) {
-            if (occurrences !== expectedReplacements) {
-                throw new Error(`Expected ${expectedReplacements} occurrences of the old string, but found ${occurrences}. This prevents accidental multiple replacements.`);
-            }
-        }
-        else if (occurrences > 1) {
-            throw new Error(`Found ${occurrences} occurrences of the old string. Use expected_replacements parameter to confirm you want to replace all ${occurrences} occurrences, or make your old_string more specific to match only the intended text.`);
-        }
-        // Perform the replacement to show preview
-        const updatedContent = currentContent.replace(new RegExp(escapeRegExp(oldString), 'g'), newString);
-        // Verify that the replacement actually changed something
-        if (updatedContent === currentContent) {
-            throw new Error(`No changes were made to the file. The old_string and new_string appear to be identical.`);
-        }
-        // Calculate change context for better preview
-        const oldLines = currentContent.split('\n');
-        const newLines = updatedContent.split('\n');
-        const changeContext = {
-            linesAdded: newLines.length - oldLines.length,
-            linesRemoved: oldLines.length > newLines.length ? oldLines.length - newLines.length : 0,
-            totalLines: newLines.length,
-            affectedLineNumbers: findAffectedLineNumbers(oldString, currentContent)
-        };
-        // Request user approval for edit operation
-        const replacementCount = expectedReplacements || 1;
-        const approvalContext = {
-            operation: 'edit',
-            filePath: filePath,
-            description: `Replace ${replacementCount} occurrence${replacementCount === 1 ? '' : 's'} of text (${oldString.length} → ${newString.length} chars)`,
-            contentPreview: createEditPreview(oldString, newString),
-            oldContent: currentContent,
-            newContent: updatedContent,
-            changeContext
-        };
-        // Request user approval for edit operation (throws UserCancellationError if cancelled)
-        await requestFileOperationApproval(approvalContext);
-        logger.debug(`✏️  Editing file: ${filePath} (${replacementCount} replacement${replacementCount === 1 ? '' : 's'})`, { component: 'EditFile', operation: 'editFile' });
-        // Write the updated content using atomic operation
-        const tempPath = `${validPath}.${randomBytes(16).toString('hex')}.tmp`;
-        try {
-            await fs.writeFile(tempPath, updatedContent, 'utf-8');
-            await fs.rename(tempPath, validPath);
-            logger.info(`✅ Successfully edited: ${filePath} (${replacementCount} replacement${replacementCount === 1 ? '' : 's'})`, { component: 'EditFile', operation: 'editFile' });
-        }
-        catch (renameError) {
-            try {
-                await fs.unlink(tempPath);
-            }
-            catch { }
-            throw renameError;
-        }
-        return `Successfully edited ${filePath} - replaced ${replacementCount} occurrence${replacementCount === 1 ? '' : 's'} of the specified text`;
-    }
-    catch (error) {
-        // Re-throw UserCancellationError without modification
-        if (isUserCancellation(error)) {
-            throw error;
-        }
-        if (error instanceof Error) {
-            throw new Error(`Failed to edit file: ${error.message}`);
-        }
-        throw new Error('Failed to edit file: Unknown error');
-    }
-}
-// Helper function to escape special regex characters
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// Helper function to find affected line numbers
-function findAffectedLineNumbers(searchString, content) {
-    const lines = content.split('\n');
-    const affectedLines = [];
-    lines.forEach((line, index) => {
-        if (line.includes(searchString)) {
-            affectedLines.push(index + 1); // Line numbers are 1-based
-        }
-    });
-    return affectedLines;
-}
-// Helper function to create a concise edit preview
-function createEditPreview(oldText, newText) {
-    const maxLength = 150;
-    const oldPreview = oldText.length > maxLength
-        ? `${oldText.substring(0, maxLength)}...`
-        : oldText;
-    const newPreview = newText.length > maxLength
-        ? `${newText.substring(0, maxLength)}...`
-        : newText;
-    return `REMOVE: "${oldPreview}"\nADD: "${newPreview}"`;
-}
-// Tool definition
+/**
+ * edit_file tool — Find-and-replace in an existing file. Requires approval.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { validatePath } from '../utils/path-validation.js';
+import { requestApproval } from '../utils/approval.js';
 export const editFileTool = {
     type: 'function',
     function: {
         name: 'edit_file',
-        description: 'Edit an existing file by replacing specific text with new text. This operation is atomic and ensures file integrity. Use this to modify configuration files, scripts, or any text files where you need to update specific sections. The old_string must match exactly, including whitespace and line breaks.',
+        description: 'Edit an existing file by replacing an exact string match with new content. ' +
+            'The old_string must match exactly (including whitespace and indentation). ' +
+            'Always read the file first to get the exact content to replace.',
         parameters: {
             type: 'object',
             properties: {
-                file_path: {
-                    type: 'string',
-                    description: 'The path to the file to edit, relative to the current working directory. Examples: "src/config.json", "README.md"'
-                },
-                old_string: {
-                    type: 'string',
-                    description: 'The exact text to find and replace. Must match exactly, including whitespace, indentation, and line breaks. For better precision, include some surrounding context.'
-                },
-                new_string: {
-                    type: 'string',
-                    description: 'The new text to replace the old_string with. Can be empty string to delete text.'
-                },
+                file_path: { type: 'string', description: 'Path to the file to edit.' },
+                old_string: { type: 'string', description: 'The exact text to find and replace.' },
+                new_string: { type: 'string', description: 'The text to replace it with.' },
                 expected_replacements: {
-                    type: 'integer',
-                    description: 'Optional: The expected number of replacements. If not specified, only allows 1 replacement. Use this to confirm when you want to replace multiple occurrences of the same text.'
-                }
+                    type: 'number',
+                    description: 'Expected number of replacements (default 1). Fails if actual count differs.',
+                },
             },
-            required: ['file_path', 'old_string', 'new_string']
-        }
-    }
+            required: ['file_path', 'old_string', 'new_string'],
+        },
+    },
 };
+export async function editFile(filePath, oldString, newString, expectedReplacements = 1, sessionId) {
+    if (oldString.length === 0) {
+        return 'Error: old_string cannot be empty.';
+    }
+    const validated = await validatePath(filePath);
+    const content = await fs.readFile(validated, 'utf8');
+    // Count occurrences
+    let count = 0;
+    let idx = 0;
+    while ((idx = content.indexOf(oldString, idx)) !== -1) {
+        count++;
+        idx += oldString.length;
+    }
+    if (count === 0) {
+        return `Error: old_string not found in ${filePath}. Make sure you read the file first and use the exact text.`;
+    }
+    if (count !== expectedReplacements) {
+        return `Error: found ${count} occurrence(s) of old_string, but expected ${expectedReplacements}. Be more specific or set expected_replacements=${count}.`;
+    }
+    // Request approval
+    const oldPreview = oldString.length > 200 ? oldString.slice(0, 200) + '...' : oldString;
+    const newPreview = newString.length > 200 ? newString.slice(0, 200) + '...' : newString;
+    const approved = await requestApproval({
+        id: `edit-${Date.now()}`,
+        type: 'file_edit',
+        description: `Edit file: ${filePath} (${count} replacement${count > 1 ? 's' : ''})`,
+        detail: `Replace:\n${oldPreview}\n\nWith:\n${newPreview}`,
+        sessionId,
+        sessionScopeKey: `file_edit:${validated}`,
+    });
+    if (!approved) {
+        return `Operation cancelled: edit to ${filePath} was rejected by user.`;
+    }
+    // Perform replacement
+    const newContent = content.split(oldString).join(newString);
+    const directory = path.dirname(validated);
+    const tempPath = path.join(directory, `.protoagent-edit-${process.pid}-${Date.now()}-${path.basename(validated)}`);
+    try {
+        await fs.writeFile(tempPath, newContent, 'utf8');
+        await fs.rename(tempPath, validated);
+    }
+    finally {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+    }
+    return `Successfully edited ${filePath}: ${count} replacement(s) made.`;
+}

package/dist/tools/index.js

@@ -1,152 +1,97 @@
-// Export all tools and their implementations
-export { readFile, readFileTool } from './read-file.js';
-export { writeFile, writeFileTool } from './write-file.js';
-export { editFile, editFileTool } from './edit-file.js';
-export { listDirectory, listDirectoryTool } from './list-directory.js';
-export { createDirectory, createDirectoryTool } from './create-directory.js';
-export { viewDirectoryTree, viewDirectoryTreeTool } from './view-directory-tree.js';
-export { searchFiles, searchFilesTool } from './search-files.js';
-export { runShellCommand, setShellConfig, setDangerouslyAcceptAll, runShellCommandTool } from './run-shell-command.js';
-export { setFileOperationConfig, setDangerouslyAcceptAllFileOps, getSessionApprovalStatus, clearSessionApprovals, showApprovalStatus } from '../utils/file-operations-approval.js';
-// Import all tool definitions
-import { readFileTool } from './read-file.js';
-import { writeFileTool } from './write-file.js';
-import { editFileTool } from './edit-file.js';
-import { listDirectoryTool } from './list-directory.js';
-import { createDirectoryTool } from './create-directory.js';
-import { viewDirectoryTreeTool } from './view-directory-tree.js';
-import { searchFilesTool } from './search-files.js';
-import { runShellCommandTool } from './run-shell-command.js';
-// Import all tool implementations
-import { readFile } from './read-file.js';
-import { writeFile } from './write-file.js';
-import { editFile } from './edit-file.js';
-import { listDirectory } from './list-directory.js';
-import { createDirectory } from './create-directory.js';
-import { viewDirectoryTree } from './view-directory-tree.js';
-import { searchFiles } from './search-files.js';
-import { runShellCommand } from './run-shell-command.js';
-import { logger } from '../utils/logger.js';
-import { isUserCancellation } from '../utils/user-cancellation.js';
-// Consolidated tool definitions
+/**
+ * Tool registry — collects all tool definitions and provides a dispatcher.
+ *
+ * Each tool file exports:
+ *  - A tool definition (OpenAI function-calling JSON schema)
+ *  - A handler function (args) => Promise<string>
+ *
+ * This file wires them together into a single `tools` array and
+ * a `handleToolCall(name, args)` dispatcher.
+ */
+import { readFileTool, readFile } from './read-file.js';
+import { writeFileTool, writeFile } from './write-file.js';
+import { editFileTool, editFile } from './edit-file.js';
+import { listDirectoryTool, listDirectory } from './list-directory.js';
+import { searchFilesTool, searchFiles } from './search-files.js';
+import { bashTool, runBash } from './bash.js';
+import { todoReadTool, todoWriteTool, readTodos, writeTodos } from './todo.js';
+import { webfetchTool, webfetch } from './webfetch.js';
+export { setDangerouslyAcceptAll, setApprovalHandler, clearApprovalHandler } from '../utils/approval.js';
+// All tool definitions — passed to the LLM
 export const tools = [
     readFileTool,
     writeFileTool,
     editFileTool,
     listDirectoryTool,
-    createDirectoryTool,
-    viewDirectoryTreeTool,
     searchFilesTool,
-    runShellCommandTool
+    bashTool,
+    todoReadTool,
+    todoWriteTool,
+    webfetchTool,
 ];
-// Tool handler function
-export async function handleToolCall(toolName, args) {
-    logger.debug('🛠️  handleToolCall invoked', {
-        component: 'ToolHandler',
-        toolName,
-        argsKeys: Object.keys(args || {})
-    });
+// Mutable tools list — MCP and sub-agent tools get appended at runtime
+let dynamicTools = [];
+export function registerDynamicTool(tool) {
+    const toolName = tool.function.name;
+    dynamicTools = dynamicTools.filter((existing) => existing.function.name !== toolName);
+    dynamicTools.push(tool);
+}
+export function unregisterDynamicTool(toolName) {
+    dynamicTools = dynamicTools.filter((tool) => tool.function.name !== toolName);
+}
+export function clearDynamicTools() {
+    dynamicTools = [];
+}
+export function getAllTools() {
+    return [...tools, ...dynamicTools];
+}
+// Dynamic tool handlers (for MCP tools, etc.)
+const dynamicHandlers = new Map();
+export function registerDynamicHandler(name, handler) {
+    dynamicHandlers.set(name, handler);
+}
+export function unregisterDynamicHandler(name) {
+    dynamicHandlers.delete(name);
+}
+/**
+ * Dispatch a tool call to the appropriate handler.
+ * Returns the tool result as a string.
+ */
+export async function handleToolCall(toolName, args, context = {}) {
     try {
-        const startTime = Date.now();
-        let result;
         switch (toolName) {
             case 'read_file':
-                logger.debug('📖 Executing read_file', { component: 'ToolHandler', filePath: args.file_path });
-                const content = await readFile(args.file_path, args.offset, args.limit);
-                result = `File content of ${args.file_path}:\n\n${content}`;
-                break;
+                return await readFile(args.file_path, args.offset, args.limit);
             case 'write_file':
-                logger.debug('✏️  Executing write_file', { component: 'ToolHandler', filePath: args.file_path, contentLength: args.content?.length });
-                result = await writeFile(args.file_path, args.content);
-                break;
+                return await writeFile(args.file_path, args.content, context.sessionId);
             case 'edit_file':
-                logger.debug('✂️  Executing edit_file', {
-                    component: 'ToolHandler',
-                    filePath: args.file_path,
-                    oldStringLength: args.old_string?.length,
-                    newStringLength: args.new_string?.length,
-                    expectedReplacements: args.expected_replacements
-                });
-                result = await editFile(args.file_path, args.old_string, args.new_string, args.expected_replacements);
-                break;
+                return await editFile(args.file_path, args.old_string, args.new_string, args.expected_replacements, context.sessionId);
             case 'list_directory':
-                logger.debug('📁 Executing list_directory', { component: 'ToolHandler', directoryPath: args.directory_path });
-                const listResult = await listDirectory(args.directory_path);
-                result = `Contents of ${args.directory_path}:\n\n${listResult}`;
-                break;
-            case 'create_directory':
-                logger.debug('📂 Executing create_directory', { component: 'ToolHandler', directoryPath: args.directory_path });
-                result = await createDirectory(args.directory_path);
-                break;
-            case 'view_directory_tree':
-                logger.debug('🌳 Executing view_directory_tree', {
-                    component: 'ToolHandler',
-                    directoryPath: args.directory_path,
-                    maxDepth: args.max_depth
-                });
-                result = await viewDirectoryTree(args.directory_path, args.max_depth);
-                break;
+                return await listDirectory(args.directory_path);
             case 'search_files':
-                logger.debug('🔍 Executing search_files', {
-                    component: 'ToolHandler',
-                    searchTerm: args.search_term,
-                    directoryPath: args.directory_path,
-                    caseSensitive: args.case_sensitive,
-                    fileExtensions: args.file_extensions
-                });
-                result = await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
-                break;
-            case 'run_shell_command':
-                logger.debug('🐚 Executing run_shell_command', {
-                    component: 'ToolHandler',
-                    command: args.command,
-                    argsCount: args.args?.length || 0,
-                    timeout: args.timeout_ms || 30000,
-                    directory: args.directory || 'current'
-                });
-                result = await runShellCommand(args.command, args.args || [], args.timeout_ms || 30000, args.directory);
-                break;
-            default:
-                logger.error('❌ Unknown tool requested', { component: 'ToolHandler', toolName });
-                result = `Error: Unknown tool ${toolName}`;
+                return await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
+            case 'bash':
+                return await runBash(args.command, args.timeout_ms, context.sessionId);
+            case 'todo_read':
+                return readTodos(context.sessionId);
+            case 'todo_write':
+                return writeTodos(args.todos, context.sessionId);
+            case 'webfetch': {
+                const result = await webfetch(args.url, args.format, args.timeout);
+                return JSON.stringify(result);
+            }
+            default: {
+                // Check dynamic handlers (MCP tools, sub-agent tools)
+                const handler = dynamicHandlers.get(toolName);
+                if (handler) {
+                    return await handler(args);
+                }
+                return `Error: Unknown tool "${toolName}"`;
+            }
         }
-        const executionTime = Date.now() - startTime;
-        logger.debug('✅ Tool execution completed', {
-            component: 'ToolHandler',
-            toolName,
-            executionTime,
-            resultLength: result.length,
-            success: !result.startsWith('Error:')
-        });
-        return result;
     }
-    catch (error) {
-        // Re-throw UserCancellationError so it can be handled properly by the agentic loop
-        if (isUserCancellation(error)) {
-            logger.debug('🚪 Re-throwing UserCancellationError for proper handling', {
-                component: 'ToolHandler',
-                toolName,
-                cancellationReason: error.message
-            });
-            throw error; // Re-throw to let the agentic loop handle it
-        }
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        logger.error('❌ Tool execution failed with exception', {
-            component: 'ToolHandler',
-            toolName,
-            error: errorMessage
-        });
-        return `Error executing ${toolName}: ${errorMessage}`;
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return `Error executing ${toolName}: ${msg}`;
     }
 }
-// Convenience functions for config setup
-import { setShellConfig, setDangerouslyAcceptAll } from './run-shell-command.js';
-import { setFileOperationConfig, setDangerouslyAcceptAllFileOps } from '../utils/file-operations-approval.js';
-export function setToolsConfig(config) {
-    setShellConfig(config);
-    setFileOperationConfig(config);
-}
-export function setToolsDangerouslyAcceptAll(accept) {
-    setDangerouslyAcceptAll(accept);
-    setDangerouslyAcceptAllFileOps(accept);
-}

package/dist/tools/list-directory.js

@@ -1,84 +1,31 @@
-import fs from 'fs/promises';
-import path from 'path';
-// Current working directory for file operations
-const workingDirectory = process.cwd();
-// Security utilities
-function normalizePath(p) {
-    return path.normalize(p);
-}
-async function validatePath(requestedPath) {
-    const absolute = path.isAbsolute(requestedPath)
-        ? path.resolve(requestedPath)
-        : path.resolve(workingDirectory, requestedPath);
-    const normalizedRequested = normalizePath(absolute);
-    // Check if path is within working directory
-    if (!normalizedRequested.startsWith(workingDirectory)) {
-        throw new Error(`Access denied - path outside working directory: ${absolute}`);
-    }
-    // Handle symlinks by checking their real path
-    try {
-        const realPath = await fs.realpath(absolute);
-        const normalizedReal = normalizePath(realPath);
-        if (!normalizedReal.startsWith(workingDirectory)) {
-            throw new Error(`Access denied - symlink target outside working directory: ${realPath}`);
-        }
-        return realPath;
-    }
-    catch (error) {
-        // For new files that don't exist yet, verify parent directory
-        if (error.code === 'ENOENT') {
-            const parentDir = path.dirname(absolute);
-            try {
-                const realParentPath = await fs.realpath(parentDir);
-                const normalizedParent = normalizePath(realParentPath);
-                if (!normalizedParent.startsWith(workingDirectory)) {
-                    throw new Error(`Access denied - parent directory outside working directory: ${realParentPath}`);
-                }
-                return absolute;
-            }
-            catch {
-                throw new Error(`Parent directory does not exist: ${parentDir}`);
-            }
-        }
-        throw error;
-    }
-}
-export async function listDirectory(dirPath) {
-    try {
-        const validPath = await validatePath(dirPath);
-        // Check if path exists and is a directory
-        const stats = await fs.stat(validPath);
-        if (!stats.isDirectory()) {
-            throw new Error('Path is not a directory');
-        }
-        const entries = await fs.readdir(validPath, { withFileTypes: true });
-        const formatted = entries
-            .map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`)
-            .join("\n");
-        return formatted || "Directory is empty";
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to list directory: ${error.message}`);
-        }
-        throw new Error('Failed to list directory: Unknown error');
-    }
-}
-// Tool definition
+/**
+ * list_directory tool — List contents of a directory.
+ */
+import fs from 'node:fs/promises';
+import { validatePath } from '../utils/path-validation.js';
 export const listDirectoryTool = {
     type: 'function',
     function: {
         name: 'list_directory',
-        description: 'List all files and directories in a specified directory. Use this to explore the project structure or find files. Returns a formatted list showing [FILE] and [DIR] prefixes.',
+        description: 'List the contents of a directory. Returns entries with [FILE] or [DIR] prefixes.',
         parameters: {
             type: 'object',
             properties: {
                 directory_path: {
                     type: 'string',
-                    description: 'The path to the directory to list, relative to the current working directory. Use "." for current directory. Examples: ".", "src", "src/components"'
-                }
+                    description: 'Path to the directory to list (relative to working directory). Defaults to ".".',
+                },
             },
-            required: ['directory_path']
-        }
-    }
+            required: [],
+        },
+    },
 };
+export async function listDirectory(directoryPath = '.') {
+    const validated = await validatePath(directoryPath);
+    const entries = await fs.readdir(validated, { withFileTypes: true });
+    const lines = entries.map((entry) => {
+        const prefix = entry.isDirectory() ? '[DIR] ' : '[FILE]';
+        return `${prefix} ${entry.name}`;
+    });
+    return `Contents of ${directoryPath} (${entries.length} entries):\n${lines.join('\n')}`;
+}