protoagent 0.0.5 → 0.1.0

package/dist/tools/search-operations.js

@@ -1,179 +0,0 @@
-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;
-    }
-}
-// Search utility function
-async function searchInFile(filePath, searchTerm, caseSensitive = false) {
-    try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const matchingLines = [];
-        let totalMatches = 0;
-        const searchPattern = caseSensitive ? searchTerm : searchTerm.toLowerCase();
-        lines.forEach((line, index) => {
-            const searchLine = caseSensitive ? line : line.toLowerCase();
-            if (searchLine.includes(searchPattern)) {
-                totalMatches++;
-                matchingLines.push(`${index + 1}: ${line}`);
-            }
-        });
-        return { matches: totalMatches, lines: matchingLines };
-    }
-    catch (error) {
-        return { matches: 0, lines: [] };
-    }
-}
-async function searchInDirectory(dirPath, searchTerm, caseSensitive = false, fileExtensions = []) {
-    const validPath = await validatePath(dirPath);
-    const results = [];
-    async function searchRecursive(currentPath, depth = 0) {
-        if (depth > 10)
-            return; // Prevent infinite recursion
-        try {
-            const entries = await fs.readdir(currentPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentPath, entry.name);
-                // Skip common directories that should be ignored
-                if (entry.isDirectory() && ['node_modules', '.git', '.DS_Store', 'dist', 'build'].includes(entry.name)) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    await searchRecursive(fullPath, depth + 1);
-                }
-                else if (entry.isFile()) {
-                    // Check file extension filter
-                    if (fileExtensions.length > 0) {
-                        const ext = path.extname(entry.name).toLowerCase();
-                        if (!fileExtensions.includes(ext)) {
-                            continue;
-                        }
-                    }
-                    try {
-                        const searchResult = await searchInFile(fullPath, searchTerm, caseSensitive);
-                        if (searchResult.matches > 0) {
-                            const relativePath = path.relative(workingDirectory, fullPath);
-                            results.push(`\n📁 ${relativePath} (${searchResult.matches} matches):`);
-                            results.push(...searchResult.lines.map(line => `  ${line}`));
-                        }
-                    }
-                    catch (error) {
-                        // Skip files we can't read
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    await searchRecursive(validPath);
-    if (results.length === 0) {
-        return `No matches found for "${searchTerm}" in ${dirPath}`;
-    }
-    return results.join('\n');
-}
-export async function searchFiles(searchTerm, dirPath = '.', caseSensitive = false, fileExtensions = []) {
-    try {
-        if (!searchTerm.trim()) {
-            throw new Error('Search term cannot be empty');
-        }
-        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('Search path must be a directory');
-        }
-        const results = await searchInDirectory(validPath, searchTerm, caseSensitive, fileExtensions);
-        const searchInfo = [
-            `🔍 Searching for: "${searchTerm}"`,
-            `📂 In directory: ${path.relative(workingDirectory, validPath) || '.'}`,
-            `📝 Case sensitive: ${caseSensitive ? 'Yes' : 'No'}`,
-            fileExtensions.length > 0 ? `🎯 File types: ${fileExtensions.join(', ')}` : '🎯 All file types',
-            '',
-        ].join('\n');
-        return searchInfo + results;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            throw new Error(`Failed to search files: ${error.message}`);
-        }
-        throw new Error('Failed to search files: Unknown error');
-    }
-}
-// Tool definitions
-export const searchTools = [
-    {
-        type: 'function',
-        function: {
-            name: 'search_files',
-            description: 'Search for a text string within files in a directory. Supports case sensitivity and file type filtering. Returns the list of files and matching lines. Use this to find specific code, configuration settings, or documentation within your project files.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    search_term: {
-                        type: 'string',
-                        description: 'The text string to search for within files.'
-                    },
-                    directory_path: {
-                        type: 'string',
-                        description: 'The directory to search within, relative to the current working directory. Use "." for the current directory.'
-                    },
-                    case_sensitive: {
-                        type: 'boolean',
-                        description: 'Whether the search should be case sensitive.'
-                    },
-                    file_extensions: {
-                        type: 'array',
-                        items: {
-                            type: 'string',
-                            description: 'File extension to include in the search (e.g., "js", "txt"). Leave empty to search all file types.'
-                        },
-                        description: 'List of file extensions to include in the search.'
-                    }
-                },
-                required: ['search_term', 'directory_path']
-            }
-        }
-    }
-];

package/dist/tools/shell-operations.js

@@ -1,342 +0,0 @@
-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/task-complete.js

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import { logger } from '../utils/logger.js';
-/**
- * Tool for the AI to explicitly signal that a task is complete
- * This gives the AI control over when to stop the agentic loop
- */
-const taskCompleteSchema = z.object({
-    summary: z.string().describe("Brief summary of what was accomplished"),
-    nextSteps: z.string().optional().describe("Optional suggestions for next steps or follow-up actions")
-});
-async function taskComplete(args) {
-    logger.debug('🏁 AI signaled task completion', { component: 'TaskComplete', summary: args.summary });
-    logger.consoleLog(`\n🏁 Task Complete: ${args.summary}`);
-    if (args.nextSteps) {
-        logger.consoleLog(`💡 Next Steps: ${args.nextSteps}`);
-    }
-    // Return a special marker that the agentic loop can detect
-    return "TASK_COMPLETE";
-}
-export const taskCompleteTool = {
-    name: 'task_complete',
-    description: 'Signal that the current task has been completed successfully. Use this when you have finished all requested work and want to return control to the user.',
-    inputSchema: taskCompleteSchema,
-    handler: taskComplete
-};
-export { taskComplete };

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

@@ -1,125 +0,0 @@
-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']
-        }
-    }
-};

package/dist/tools.js

@@ -1,2 +0,0 @@
-// Re-export everything from the tools directory
-export * from './tools/index.js';