protoagent 0.0.1

package/dist/tools/list-directory.js

@@ -0,0 +1,84 @@
+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
+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.',
+        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"'
+                }
+            },
+            required: ['directory_path']
+        }
+    }
+};

package/dist/tools/read-file.js

@@ -0,0 +1,111 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Configuration constants
+const DEFAULT_READ_LIMIT = 2000;
+const MAX_LINE_LENGTH = 2000;
+// 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 readFile(filePath, offset, limit) {
+    try {
+        const validPath = await validatePath(filePath);
+        // Check if file exists and is actually a file
+        const stats = await fs.stat(validPath);
+        if (!stats.isFile()) {
+            throw new Error('Path is not a file');
+        }
+        // Read and return file content
+        const content = await fs.readFile(validPath, 'utf-8');
+        const lines = content.split('\n');
+        // Apply offset and limit if specified
+        const startLine = offset ? Math.max(0, offset - 1) : 0; // Convert to 0-based indexing
+        const endLine = limit ? Math.min(lines.length, startLine + limit) : Math.min(lines.length, startLine + DEFAULT_READ_LIMIT);
+        // Truncate lines that are too long
+        const processedLines = lines.slice(startLine, endLine).map(line => line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + '...[truncated]' : line);
+        const result = processedLines.join('\n');
+        // Add metadata if file was truncated or offset was used
+        let metadata = '';
+        if (offset && offset > 1) {
+            metadata += `\n[File started at line ${offset}]`;
+        }
+        if (endLine < lines.length) {
+            metadata += `\n[File truncated - showing lines ${startLine + 1}-${endLine} of ${lines.length} total lines]`;
+        }
+        if (processedLines.some(line => line.includes('...[truncated]'))) {
+            metadata += `\n[Some lines truncated at ${MAX_LINE_LENGTH} characters]`;
+        }
+        return result + metadata;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to read file: ${error.message}`);
+        }
+        throw new Error('Failed to read file: Unknown error');
+    }
+}
+// Tool definition
+export const readFileTool = {
+    type: 'function',
+    function: {
+        name: 'read_file',
+        description: 'Read the contents of a file in the current working directory or its subdirectories. Use this when you need to examine code, configuration files, or any text-based files to help the user. Supports reading specific line ranges for large files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to read, relative to the current working directory. Examples: "src/index.ts", "package.json", "README.md"'
+                },
+                offset: {
+                    type: 'integer',
+                    description: 'Optional: The 1-based line number to start reading from. If not specified, reads from the beginning of the file.'
+                },
+                limit: {
+                    type: 'integer',
+                    description: 'Optional: The maximum number of lines to read. If not specified, reads up to 2000 lines. Use this with offset to read specific sections of large files.'
+                }
+            },
+            required: ['file_path']
+        }
+    }
+};

package/dist/tools/run-shell-command.js

@@ -0,0 +1,340 @@
+import { spawn } from 'child_process';
+import inquirer from 'inquirer';
+// Current working directory for file operations
+const workingDirectory = process.cwd();
+// Global flags and session state
+let globalConfig = null;
+let dangerouslyAcceptAll = false;
+let approvedCommandsForSession = new Set();
+// Whitelisted safe commands that don't require confirmation
+const SAFE_COMMANDS = [
+    'ls', 'dir', 'pwd', 'whoami', 'date', 'echo', 'cat', 'head', 'tail',
+    'grep', 'find', 'wc', 'sort', 'uniq', 'cut', 'awk', 'sed',
+    'git status', 'git log', 'git diff', 'git branch', 'git show',
+    'npm list', 'npm ls', 'yarn list', 'node --version', 'npm --version',
+    'python --version', 'python3 --version', 'which', 'type', 'file'
+];
+export function setShellConfig(config) {
+    globalConfig = config;
+}
+export function setDangerouslyAcceptAll(accept) {
+    dangerouslyAcceptAll = accept;
+}
+export async function runShellCommand(command, args = [], timeoutMs = 30000) {
+    return await runShellCommandWithRetry(command, args, timeoutMs, 0);
+}
+async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, retryCount = 0) {
+    const maxRetries = 2;
+    try {
+        // Security: Basic validation to prevent obviously dangerous commands
+        const dangerousCommands = ['rm -rf', 'sudo', 'su', 'chmod 777', 'dd if=', 'mkfs', 'fdisk', 'format'];
+        const fullCommand = `${command} ${args.join(' ')}`.toLowerCase();
+        for (const dangerous of dangerousCommands) {
+            if (fullCommand.includes(dangerous)) {
+                throw new Error(`Command contains potentially dangerous operation: ${dangerous}`);
+            }
+        }
+        const commandString = `${command} ${args.join(' ')}`;
+        const baseCommand = command.toLowerCase();
+        // Check if we should auto-approve (only show approval prompt on first attempt)
+        if (retryCount === 0) {
+            if (dangerouslyAcceptAll) {
+                console.log(`🚀 Auto-executing (--dangerously-accept-all): ${commandString}`);
+            }
+            else if (approvedCommandsForSession.has(baseCommand)) {
+                console.log(`🚀 Auto-executing (${baseCommand} approved for session): ${commandString}`);
+            }
+            else {
+                // Check if it's a safe command
+                const isSafeCommand = SAFE_COMMANDS.some(safe => {
+                    const normalizedSafe = safe.toLowerCase();
+                    const normalizedFull = fullCommand.toLowerCase();
+                    return normalizedFull === normalizedSafe ||
+                        (normalizedSafe.includes(' ') && normalizedFull.startsWith(normalizedSafe)) ||
+                        (!normalizedSafe.includes(' ') && normalizedFull.split(' ')[0] === normalizedSafe);
+                });
+                if (isSafeCommand) {
+                    console.log(`🟢 Executing safe command: ${commandString}`);
+                }
+                else {
+                    // Require user confirmation with enhanced options
+                    console.log(`\n🔐 Shell Command Requested: ${commandString}`);
+                    console.log(`📁 Working Directory: ${workingDirectory}`);
+                    const { choice } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'choice',
+                            message: 'Choose your action:',
+                            choices: [
+                                { name: '1. ✅ Execute this command now', value: 'execute' },
+                                { name: `2. ✅ Execute and approve all "${baseCommand}" commands for this session`, value: 'approve_session' },
+                                { name: '3. ❌ Cancel and suggest alternative', value: 'cancel' }
+                            ],
+                            default: 'execute'
+                        }
+                    ]);
+                    switch (choice) {
+                        case 'execute':
+                            console.log(`🚀 Executing: ${commandString}`);
+                            break;
+                        case 'approve_session':
+                            approvedCommandsForSession.add(baseCommand);
+                            console.log(`🔓 "${baseCommand}" approved for session - all future ${baseCommand} commands will auto-execute`);
+                            console.log(`🚀 Executing: ${commandString}`);
+                            break;
+                        case 'cancel':
+                            return getSuggestion(commandString);
+                        default:
+                            return `Command execution cancelled by user: ${commandString}`;
+                    }
+                }
+            }
+        }
+        else {
+            console.log(`🔄 Retry attempt ${retryCount}/${maxRetries}: ${commandString}`);
+        }
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd: workingDirectory,
+                stdio: ['pipe', 'pipe', 'pipe'], // Capture all input/output for AI processing
+                shell: true,
+                env: { ...process.env, PATH: process.env.PATH }
+            });
+            let stdout = '';
+            let stderr = '';
+            let completed = false;
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                if (!completed) {
+                    completed = true;
+                    child.kill('SIGTERM');
+                    reject(new Error(`TIMEOUT_ERROR:${timeoutMs}`));
+                }
+            }, timeoutMs);
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (!completed) {
+                    completed = true;
+                    clearTimeout(timeout);
+                    const output = stdout + (stderr ? `\nSTDERR:\n${stderr}` : '');
+                    if (code === 0) {
+                        resolve(`Command executed successfully (exit code: ${code})\n\nOutput:\n${output || '(no output)'}`);
+                    }
+                    else {
+                        // For non-zero exit codes, still return the output but indicate the failure
+                        resolve(`Command exited with code ${code}\n\nOutput:\n${output || '(no output)'}`);
+                    }
+                }
+            });
+            child.on('error', (error) => {
+                if (!completed) {
+                    completed = true;
+                    clearTimeout(timeout);
+                    reject(new Error(`Failed to execute command: ${error.message}`));
+                }
+            });
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            // Check if this is a timeout error and we haven't exceeded max retries
+            if (error.message.startsWith('TIMEOUT_ERROR:') && retryCount < maxRetries) {
+                const timeoutDuration = parseInt(error.message.split(':')[1]);
+                return await analyzeTimeoutAndRetry(command, args, timeoutDuration, retryCount);
+            }
+            throw new Error(`Shell command error: ${error.message.replace('TIMEOUT_ERROR:', 'Command timed out after ').replace(/:\d+/, 'ms')}`);
+        }
+        throw new Error('Shell command error: Unknown error');
+    }
+}
+async function analyzeTimeoutAndRetry(command, args = [], originalTimeout, retryCount) {
+    const commandString = `${command} ${args.join(' ')}`;
+    console.log(`⏱️  Command timed out after ${originalTimeout}ms: ${commandString}`);
+    console.log(`🔍 Analyzing timeout cause and preparing retry...`);
+    // Analyze the command to understand why it might have timed out
+    const analysis = analyzeCommandForTimeout(command, args);
+    console.log(`💡 Timeout analysis: ${analysis.reason}`);
+    if (analysis.suggestedArgs.length > 0) {
+        console.log(`🔧 Suggested fix: ${command} ${analysis.suggestedArgs.join(' ')}`);
+        // Try with suggested arguments
+        return await runShellCommandWithRetry(command, analysis.suggestedArgs, analysis.suggestedTimeout, retryCount + 1);
+    }
+    else if (analysis.suggestedTimeout > originalTimeout) {
+        console.log(`⏰ Increasing timeout to ${analysis.suggestedTimeout}ms for long-running operation`);
+        // Try with longer timeout
+        return await runShellCommandWithRetry(command, args, analysis.suggestedTimeout, retryCount + 1);
+    }
+    else {
+        // No specific fix found, provide analysis
+        return `Command timed out after ${originalTimeout}ms: ${commandString}\n\nTimeout Analysis: ${analysis.reason}\n\nSuggestion: ${analysis.suggestion}`;
+    }
+}
+function analyzeCommandForTimeout(command, args) {
+    const fullCommand = `${command} ${args.join(' ')}`.toLowerCase();
+    const baseCommand = command.toLowerCase();
+    // Interactive command detection
+    if (baseCommand === 'npm' && args.length > 0) {
+        const npmSubcommand = args[0].toLowerCase();
+        if (npmSubcommand === 'create' || npmSubcommand === 'init') {
+            // Check if template is specified for npm create
+            if (npmSubcommand === 'create' && !args.some(arg => arg.includes('--template'))) {
+                return {
+                    reason: "npm create command likely waiting for interactive template selection",
+                    suggestion: "Add --template flag to avoid interactive prompts",
+                    suggestedArgs: [...args, '--template', 'vanilla'],
+                    suggestedTimeout: 60000
+                };
+            }
+            // Check for other interactive npm commands
+            if (!args.some(arg => arg.includes('-y') || arg.includes('--yes'))) {
+                return {
+                    reason: "npm command likely waiting for interactive confirmation",
+                    suggestion: "Add -y flag to auto-confirm prompts",
+                    suggestedArgs: [...args, '-y'],
+                    suggestedTimeout: 60000
+                };
+            }
+        }
+        if (npmSubcommand === 'install' || npmSubcommand === 'i') {
+            return {
+                reason: "npm install operations can take a long time",
+                suggestion: "Increase timeout for package installation",
+                suggestedArgs: args,
+                suggestedTimeout: 120000 // 2 minutes
+            };
+        }
+    }
+    // Git operations
+    if (baseCommand === 'git') {
+        const gitSubcommand = args[0]?.toLowerCase();
+        if (['clone', 'pull', 'push', 'fetch'].includes(gitSubcommand)) {
+            return {
+                reason: "Git network operations can be slow",
+                suggestion: "Increase timeout for network operations",
+                suggestedArgs: args,
+                suggestedTimeout: 90000 // 1.5 minutes
+            };
+        }
+        if (gitSubcommand === 'commit' && !args.some(arg => arg.includes('-m'))) {
+            return {
+                reason: "Git commit without -m flag opens interactive editor",
+                suggestion: "Add commit message with -m flag",
+                suggestedArgs: [...args, '-m', '"Auto-commit"'],
+                suggestedTimeout: 30000
+            };
+        }
+    }
+    // Yarn operations
+    if (baseCommand === 'yarn') {
+        if (args.length === 0 || args[0] === 'install') {
+            return {
+                reason: "Yarn install operations can take a long time",
+                suggestion: "Increase timeout for package installation",
+                suggestedArgs: args,
+                suggestedTimeout: 120000 // 2 minutes
+            };
+        }
+        if (args[0] === 'create' && !args.some(arg => arg.includes('--template'))) {
+            return {
+                reason: "yarn create command likely waiting for interactive input",
+                suggestion: "Add template specification to avoid prompts",
+                suggestedArgs: [...args, '--template', 'default'],
+                suggestedTimeout: 60000
+            };
+        }
+    }
+    // Build operations
+    if (['build', 'compile', 'webpack', 'rollup', 'vite'].includes(baseCommand)) {
+        return {
+            reason: "Build operations often require more time",
+            suggestion: "Increase timeout for build processes",
+            suggestedArgs: args,
+            suggestedTimeout: 120000 // 2 minutes
+        };
+    }
+    // Testing operations  
+    if (['test', 'jest', 'mocha', 'karma'].includes(baseCommand) ||
+        (baseCommand === 'npm' && args[0] === 'test')) {
+        return {
+            reason: "Test operations can take significant time",
+            suggestion: "Increase timeout for test execution",
+            suggestedArgs: args,
+            suggestedTimeout: 90000 // 1.5 minutes
+        };
+    }
+    // Python operations
+    if (['python', 'python3', 'pip', 'pip3'].includes(baseCommand)) {
+        if (args.some(arg => arg.includes('install'))) {
+            return {
+                reason: "Python package installation can be slow",
+                suggestion: "Increase timeout for package installation",
+                suggestedArgs: args,
+                suggestedTimeout: 120000 // 2 minutes
+            };
+        }
+    }
+    // Default analysis for unknown timeouts
+    return {
+        reason: "Command exceeded default timeout, possibly due to network delays, large operations, or interactive prompts",
+        suggestion: "Try adding flags to make the command non-interactive (like -y, --yes, --no-interactive) or check if the command is waiting for user input",
+        suggestedArgs: [],
+        suggestedTimeout: 60000 // 1 minute default increase
+    };
+}
+// Helper function to provide suggestions for cancelled commands
+function getSuggestion(commandString) {
+    const suggestions = {
+        'rm': 'Consider using file tools like write_file or edit_file to manage files safely',
+        'sudo': 'ProtoAgent runs with your user permissions only for security',
+        'npm install': 'Try: Use the file tools to examine package.json first, then I can suggest safer alternatives',
+        'npm create': 'Add flags to avoid interactive prompts: npm create vite@latest my-app --template react',
+        'git push': 'Consider: First check git status, then review changes before pushing',
+        'chmod': 'Consider: Use file tools to check permissions first, specific chmod may not be needed'
+    };
+    const cmd = commandString.split(' ')[0].toLowerCase();
+    const fullCmd = commandString.toLowerCase();
+    // Check for interactive command patterns
+    if (fullCmd.includes('npm create') && !fullCmd.includes('--template')) {
+        return `Command cancelled: ${commandString}\n\n💡 Suggestion: npm create commands require template specification to avoid interactive prompts. Try: npm create vite@latest my-app --template react\n\nAvailable templates: vanilla, vue, react, preact, lit, svelte, solid, qwik, angular`;
+    }
+    if (fullCmd.includes('git commit') && !fullCmd.includes('-m')) {
+        return `Command cancelled: ${commandString}\n\n💡 Suggestion: git commit requires a message flag to avoid opening an interactive editor. Try: git commit -m "Your commit message"`;
+    }
+    const suggestion = suggestions[cmd] || suggestions[fullCmd.split(' ').slice(0, 2).join(' ')] ||
+        'Consider using the available file system tools (read_file, write_file, list_directory) for safer operations, or add flags to make commands non-interactive';
+    return `Command cancelled: ${commandString}\n\n💡 Suggestion: ${suggestion}\n\nYou can:\n- Use 'protoagent --dangerously-accept-all' to auto-approve all commands\n- Choose option 2 next time to approve commands for the session\n- Add flags to make commands non-interactive (e.g., --template, --yes, --no-interactive, -m for git)\n- ProtoAgent can automatically retry timed-out commands with better parameters\n- Ask me to break down the task into safer operations`;
+}
+// Tool definition
+export const runShellCommandTool = {
+    type: 'function',
+    function: {
+        name: 'run_shell_command',
+        description: 'Execute a shell command in the current working directory. Commands run non-interactively and output is captured for analysis. For tools that normally prompt for input (like npm create), provide all necessary flags to avoid interactive prompts. Safe commands (ls, find, grep, git status, etc.) run automatically. Other commands may require user confirmation unless running with --dangerously-accept-all flag. Examples: find . -name "*.js", grep -r "TODO" ., npm create vite@latest my-app --template react --no-interactive',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The command to execute. Examples: "find", "grep", "ls", "git", "npm", "python", "node", "yarn"'
+                },
+                args: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Arguments to pass to the command. Examples: [".", "-name", "*.js"] for find, ["-r", "TODO", "."] for grep, ["-la"] for ls'
+                },
+                timeout_ms: {
+                    type: 'integer',
+                    description: 'Timeout in milliseconds for the command execution. Default is 30000 (30 seconds). Use higher values for long-running operations.'
+                }
+            },
+            required: ['command']
+        }
+    }
+};