protoagent 0.0.1

package/dist/tools/shell-operations.js

@@ -0,0 +1,342 @@
+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 definitions
+export const shellTools = [
+    {
+        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']
+            }
+        }
+    }
+];

package/dist/tools/todo.js

@@ -0,0 +1,177 @@
+/**
+ * Todo management tool for ProtoAgent
+ */
+import { z } from 'zod';
+// Define the todo item schema
+const TodoItemSchema = z.object({
+    id: z.string().describe('Unique identifier for the todo item'),
+    content: z.string().describe('Brief description of the task'),
+    status: z.enum(['pending', 'in_progress', 'completed', 'cancelled']).describe('Current status of the task'),
+    priority: z.enum(['high', 'medium', 'low']).describe('Priority level of the task'),
+    created: z.string().optional().describe('Creation timestamp'),
+    updated: z.string().optional().describe('Last update timestamp')
+});
+// In-memory storage for todo items (could be persisted to file later)
+const todoStorage = {};
+/**
+ * Get current session ID (simplified - could use actual session management)
+ */
+function getCurrentSessionId() {
+    return 'default_session';
+}
+/**
+ * Generate a unique ID for todo items
+ */
+function generateTodoId() {
+    return `todo_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Tool for reading the current todo list
+ */
+export const todoReadTool = {
+    type: 'function',
+    function: {
+        name: 'todo_read',
+        description: 'Read the current todo list to see all tasks and their status',
+        parameters: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    }
+};
+/**
+ * Tool for writing/updating the todo list
+ */
+export const todoWriteTool = {
+    type: 'function',
+    function: {
+        name: 'todo_write',
+        description: 'Update the todo list by providing a complete list of todos with their current status. Use this to add new todos, update existing ones, or mark items as completed.',
+        parameters: {
+            type: 'object',
+            properties: {
+                todos: {
+                    type: 'array',
+                    description: 'The complete updated todo list',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: {
+                                type: 'string',
+                                description: 'Unique identifier for the todo item. Use existing ID to update, or provide new ID for new items.'
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'Brief description of the task'
+                            },
+                            status: {
+                                type: 'string',
+                                enum: ['pending', 'in_progress', 'completed', 'cancelled'],
+                                description: 'Current status of the task'
+                            },
+                            priority: {
+                                type: 'string',
+                                enum: ['high', 'medium', 'low'],
+                                description: 'Priority level of the task'
+                            }
+                        },
+                        required: ['id', 'content', 'status', 'priority']
+                    }
+                }
+            },
+            required: ['todos']
+        }
+    }
+};
+/**
+ * Handle todo read operation
+ */
+export async function handleTodoRead() {
+    const sessionId = getCurrentSessionId();
+    const todos = todoStorage[sessionId] || [];
+    if (todos.length === 0) {
+        return 'Todo list is empty. No tasks found.';
+    }
+    const activeTodos = todos.filter(t => t.status !== 'completed');
+    const completedTodos = todos.filter(t => t.status === 'completed');
+    let result = `Todo List (${activeTodos.length} active, ${completedTodos.length} completed):\n\n`;
+    // Show active todos first
+    if (activeTodos.length > 0) {
+        result += '📋 ACTIVE TASKS:\n';
+        activeTodos.forEach((todo, index) => {
+            const priorityIcon = todo.priority === 'high' ? '🔴' : todo.priority === 'medium' ? '🟡' : '🟢';
+            const statusIcon = todo.status === 'in_progress' ? '🔄' : '⏳';
+            result += `${index + 1}. ${statusIcon} ${priorityIcon} ${todo.content} [${todo.status.toUpperCase()}]\n`;
+            result += `   ID: ${todo.id}\n\n`;
+        });
+    }
+    // Show completed todos
+    if (completedTodos.length > 0) {
+        result += '✅ COMPLETED TASKS:\n';
+        completedTodos.forEach((todo, index) => {
+            result += `${index + 1}. ✅ ${todo.content}\n`;
+            result += `   ID: ${todo.id}\n\n`;
+        });
+    }
+    return result.trim();
+}
+/**
+ * Handle todo write operation
+ */
+export async function handleTodoWrite(todos) {
+    const sessionId = getCurrentSessionId();
+    try {
+        // Validate and process todos
+        const validatedTodos = [];
+        const timestamp = new Date().toISOString();
+        for (const todo of todos) {
+            // Parse and validate each todo item
+            const parsed = TodoItemSchema.parse({
+                ...todo,
+                updated: timestamp,
+                created: todo.created || timestamp
+            });
+            validatedTodos.push(parsed);
+        }
+        // Update storage
+        todoStorage[sessionId] = validatedTodos;
+        // Generate summary
+        const activeTodos = validatedTodos.filter(t => t.status !== 'completed');
+        const completedTodos = validatedTodos.filter(t => t.status === 'completed');
+        const highPriorityTodos = activeTodos.filter(t => t.priority === 'high');
+        let result = `✅ Todo list updated successfully!\n\n`;
+        result += `📊 Summary:\n`;
+        result += `- Total tasks: ${validatedTodos.length}\n`;
+        result += `- Active tasks: ${activeTodos.length}\n`;
+        result += `- Completed tasks: ${completedTodos.length}\n`;
+        result += `- High priority tasks: ${highPriorityTodos.length}\n\n`;
+        if (highPriorityTodos.length > 0) {
+            result += `🔴 HIGH PRIORITY TASKS:\n`;
+            highPriorityTodos.forEach((todo, index) => {
+                const statusIcon = todo.status === 'in_progress' ? '🔄' : '⏳';
+                result += `${index + 1}. ${statusIcon} ${todo.content}\n`;
+            });
+        }
+        return result.trim();
+    }
+    catch (error) {
+        return `❌ Error updating todo list: ${error instanceof Error ? error.message : 'Unknown error'}`;
+    }
+}
+/**
+ * Main todo tool handler
+ */
+export async function handleTodoTool(toolName, args) {
+    switch (toolName) {
+        case 'todo_read':
+            return await handleTodoRead();
+        case 'todo_write':
+            if (!args.todos || !Array.isArray(args.todos)) {
+                return '❌ Error: todos parameter must be an array';
+            }
+            return await handleTodoWrite(args.todos);
+        default:
+            return `❌ Unknown todo tool: ${toolName}`;
+    }
+}

package/dist/tools/view-directory-tree.js

@@ -0,0 +1,125 @@
+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;
+    }
+}
+// Directory tree utility function
+async function buildDirectoryTree(dirPath, prefix = '', isLast = true, maxDepth = 5, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        return '';
+    }
+    const validPath = await validatePath(dirPath);
+    const stats = await fs.stat(validPath);
+    if (!stats.isDirectory()) {
+        return '';
+    }
+    let result = '';
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    // Sort entries: directories first, then files, alphabetically
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const isLastEntry = i === entries.length - 1;
+        const currentPrefix = isLastEntry ? '└── ' : '├── ';
+        const nextPrefix = prefix + (isLastEntry ? '    ' : '│   ');
+        result += `${prefix}${currentPrefix}${entry.name}${entry.isDirectory() ? '/' : ''}\n`;
+        if (entry.isDirectory()) {
+            const subPath = path.join(dirPath, entry.name);
+            try {
+                result += await buildDirectoryTree(subPath, nextPrefix, isLastEntry, maxDepth, currentDepth + 1);
+            }
+            catch (error) {
+                // Skip directories we can't read (permissions, etc.)
+                result += `${nextPrefix}└── [Permission Denied]\n`;
+            }
+        }
+    }
+    return result;
+}
+export async function viewDirectoryTree(dirPath, maxDepth = 5) {
+    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 relativePath = path.relative(workingDirectory, validPath) || '.';
+        const tree = await buildDirectoryTree(validPath, '', true, maxDepth);
+        return `Directory tree for ${relativePath}:\n${relativePath}/\n${tree}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to view directory tree: ${error.message}`);
+        }
+        throw new Error('Failed to view directory tree: Unknown error');
+    }
+}
+// Tool definition
+export const viewDirectoryTreeTool = {
+    type: 'function',
+    function: {
+        name: 'view_directory_tree',
+        description: 'Display the directory tree of a specified directory up to a certain depth. This provides a visual overview of the directory structure, showing nested folders and files. Useful for understanding project layout or finding files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                directory_path: {
+                    type: 'string',
+                    description: 'The path to the directory to display, relative to the current working directory. Examples: "src", "docs"'
+                },
+                max_depth: {
+                    type: 'integer',
+                    description: 'The maximum depth to display in the directory tree. Use a higher number to show more levels of the tree.'
+                }
+            },
+            required: ['directory_path']
+        }
+    }
+};