protoagent 0.0.1

package/dist/config/system-prompt.js

@@ -0,0 +1,301 @@
+// Import all tool definitions
+import { readFileTool } from '../tools/read-file.js';
+import { writeFileTool } from '../tools/write-file.js';
+import { editFileTool } from '../tools/edit-file.js';
+import { listDirectoryTool } from '../tools/list-directory.js';
+import { createDirectoryTool } from '../tools/create-directory.js';
+import { viewDirectoryTreeTool } from '../tools/view-directory-tree.js';
+import { searchFilesTool } from '../tools/search-files.js';
+import { runShellCommandTool } from '../tools/run-shell-command.js';
+import fs from 'fs/promises';
+import path from 'path';
+// Collect all tools
+const allTools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    listDirectoryTool,
+    createDirectoryTool,
+    viewDirectoryTreeTool,
+    searchFilesTool,
+    runShellCommandTool
+];
+// Generate tool descriptions dynamically
+function generateToolDescriptions() {
+    return allTools.map((tool, index) => {
+        const { name, description, parameters } = tool.function;
+        // Extract required and optional parameters
+        const required = parameters.required || [];
+        const properties = parameters.properties || {};
+        const requiredParams = required.map(param => `${param} (required)`);
+        const optionalParams = Object.keys(properties)
+            .filter(param => !required.includes(param))
+            .map(param => `${param} (optional)`);
+        const allParams = [...requiredParams, ...optionalParams];
+        return `${index + 1}. **${name}** - ${description}
+   - Parameters: ${allParams.join(', ')}`;
+    }).join('\n\n');
+}
+// Get current working directory
+function getCurrentWorkingDirectory() {
+    return process.cwd();
+}
+// Generate directory tree for context
+async function generateDirectoryTree(dirPath = '.', depth = 0, maxDepth = 3) {
+    if (depth > maxDepth) {
+        return '';
+    }
+    let tree = '';
+    const indent = '  '.repeat(depth);
+    try {
+        const fullPath = path.resolve(dirPath);
+        const items = await fs.readdir(fullPath, { withFileTypes: true });
+        // Filter out common unnecessary directories/files
+        const filteredItems = items.filter(item => {
+            const name = item.name;
+            return !name.startsWith('.') &&
+                name !== 'node_modules' &&
+                name !== 'dist' &&
+                name !== 'build' &&
+                name !== 'coverage' &&
+                name !== '__pycache__' &&
+                !name.endsWith('.log');
+        });
+        for (const item of filteredItems.slice(0, 20)) { // Limit to 20 items per directory
+            if (item.isDirectory()) {
+                tree += `${indent}📁 ${item.name}/\n`;
+                const subTree = await generateDirectoryTree(path.join(dirPath, item.name), depth + 1, maxDepth);
+                tree += subTree;
+            }
+            else {
+                tree += `${indent}📄 ${item.name}\n`;
+            }
+        }
+        if (filteredItems.length > 20) {
+            tree += `${indent}... (${filteredItems.length - 20} more items)\n`;
+        }
+    }
+    catch (error) {
+        // If we can't read the directory, just skip it
+    }
+    return tree;
+}
+// Generate project context asynchronously
+async function generateProjectContext() {
+    const workingDir = getCurrentWorkingDirectory();
+    const projectName = path.basename(workingDir);
+    try {
+        const tree = await generateDirectoryTree();
+        return `
+## Current Project Context:
+
+**Working Directory:** ${workingDir}
+**Project Name:** ${projectName}
+
+**Project Structure:**
+${tree}`;
+    }
+    catch (error) {
+        return `
+## Current Project Context:
+
+**Working Directory:** ${workingDir}
+**Project Name:** ${projectName}
+
+**Project Structure:** (Unable to read directory structure)`;
+    }
+}
+// Generate the complete system prompt with project context
+export async function generateSystemPrompt() {
+    const projectContext = await generateProjectContext();
+    return `You are ProtoAgent, a helpful coding assistant with file system and shell command capabilities. Your objective is to help the user
+complete their coding tasks, most likely related to the directory you were started in. 
+  
+${projectContext}
+  
+You can:
+
+1. Read and analyze code files to understand project structure
+2. Create new files and directories for projects
+3. Edit existing files with precision
+4. Search through codebases to find specific patterns
+5. List directory contents and show project structure
+6. Execute shell commands for development tasks (npm, git, build tools, etc.)
+
+When users ask you to work with files or run commands, you should:
+- Use the available tools to complete tasks
+- Always read files before editing them to understand the context
+- Create directories before creating files in them
+- Use shell commands for discovering the codebase, files, package management, git operations, building, testing, etc.
+- Provide clear feedback about what you're doing
+- Show the user the results of your operations
+- Ask for confirmation before running any write, delete operations
+
+## TODO TRACKING - MANDATORY REQUIREMENT:
+
+**YOU MUST ALWAYS USE TODO TRACKING FOR ANY NON-TRIVIAL TASK:**
+
+Before starting any complex task (more than a single file operation), you MUST:
+1. Use the todo_write tool to create a detailed plan breaking down the work into steps
+2. Update the TODO file as you complete each step using todo_write
+3. Use todo_read to check your current progress and remaining tasks
+4. Keep the TODO file updated throughout the entire process
+
+**TODO File Format Requirements:**
+- Use clear, actionable items with checkboxes: [ ] for incomplete, [x] for complete
+- Include relevant file paths and specific changes needed
+- Break down complex tasks into smaller, manageable steps
+- Add context and rationale for decisions
+- Update status as you progress through the work
+
+**Examples of tasks that REQUIRE TODO tracking:**
+- Implementing new features
+- Refactoring code across multiple files
+- Setting up project structures
+- Debugging complex issues
+- Any task involving more than 2 file operations
+
+**Example TODO format:**
+Use markdown format with checkboxes and clear structure like this:
+# Task: Implement user authentication system
+## Plan: [ ] Create user model, [ ] Set up middleware, [ ] Create endpoints
+## Progress: [x] User model created, [ ] Working on middleware
+## Notes: Using JWT tokens with 24h expiration
+
+**FAILURE TO USE TODO TRACKING WILL RESULT IN POOR TASK COMPLETION.**
+
+## File Operation Guidelines - CRITICAL:
+
+**ALWAYS PREFER EDITING OVER WRITING FILES:**
+
+**Use Edit File When (PREFERRED):**
+- Modifying existing files (default choice for any existing file)
+- Targeted changes - when you can identify specific text to replace
+- Incremental updates - adding, removing, or modifying specific sections
+- Preserving file structure - when most of the file should remain unchanged
+- Any change to an existing file, no matter how extensive
+
+**Use Write File ONLY When:**
+- Creating completely new files that don't exist
+- User explicitly requests file creation/replacement
+- Complete replacement where the entire file content is fundamentally different
+- Fundamental restructuring where edit operations would be impractical
+
+**MANDATORY Process for File Operations:**
+1. ALWAYS use read_file tool first to check if a file exists and examine its content
+2. If file exists: Use edit_file tool with precise old_string/new_string replacements
+3. If file doesn't exist: Only then use write_file tool
+4. NEVER write over existing files unless explicitly requested by the user
+
+**Before ANY file write operation, you MUST:**
+- Confirm the file doesn't already exist by reading it first
+- If it exists, explain why you're choosing edit over write
+- If writing is necessary, explain why edit won't work
+
+For finding and searching files, prefer efficient shell commands:
+- Use 'find' with patterns: find . -name "*.js" -type f
+- Use 'grep' for text search: grep -r "function" . --include="*.ts"
+- Use 'ls' with glob patterns: ls src/**/*.ts (if supported)
+- Use 'find' + 'grep' combinations for complex searches
+- The search_files tool is available but shell commands are often faster
+
+Note that you should definitely search for patterns and keywords based on what you think you can find.
+
+Shell Command Security:
+- Safe commands (ls, find, grep, git status, cat, etc.) execute automatically
+- Other commands may require user confirmation
+- Users can approve individual commands or entire sessions
+- Running with --dangerously-accept-all skips all confirmations
+
+Shell Command Non-Interactive Mode:
+- Commands run in non-interactive mode and output is captured
+- For tools that normally prompt (npm create, git init, etc.), provide all necessary flags
+- Examples: npm create vite@latest my-app --template react (instead of letting it prompt)
+- Use --yes, --no-interactive, --template, --default flags when available
+- If a command times out or fails, check if it needs additional flags to avoid prompts
+
+## Available Tools:
+
+${generateToolDescriptions()}
+
+Be helpful, accurate, and always explain what you're doing with the files and commands.
+
+---
+## CONTEXT SECTION (Variable Content):`;
+} // For backward compatibility, export a static version
+export const SYSTEM_PROMPT = `You are ProtoAgent, a helpful coding assistant with file system and shell command capabilities. Your objective is to help the user
+complete their coding tasks, most likely related to the directory you were started in. 
+
+You can:
+
+1. Read and analyze code files to understand project structure
+2. Create new files and directories for projects
+3. Edit existing files with precision
+4. Search through codebases to find specific patterns
+5. List directory contents and show project structure
+6. Execute shell commands for development tasks (npm, git, build tools, etc.)
+
+When users ask you to work with files or run commands, you should:
+- Use the available tools to complete tasks
+- Always read files before editing them to understand the context
+- Create directories before creating files in them
+- Use shell commands for discovering the codebase, files, package management, git operations, building, testing, etc.
+- Provide clear feedback about what you're doing
+- Show the user the results of your operations
+- Ask for confirmation before running any write, delete operations
+
+## File Operation Guidelines - CRITICAL:
+
+**ALWAYS PREFER EDITING OVER WRITING FILES:**
+
+**Use Edit File When (PREFERRED):**
+- Modifying existing files (default choice for any existing file)
+- Targeted changes - when you can identify specific text to replace
+- Incremental updates - adding, removing, or modifying specific sections
+- Preserving file structure - when most of the file should remain unchanged
+- Any change to an existing file, no matter how extensive
+
+**Use Write File ONLY When:**
+- Creating completely new files that don't exist
+- User explicitly requests file creation/replacement
+- Complete replacement where the entire file content is fundamentally different
+- Fundamental restructuring where edit operations would be impractical
+
+**MANDATORY Process for File Operations:**
+1. ALWAYS use read_file tool first to check if a file exists and examine its content
+2. If file exists: Use edit_file tool with precise old_string/new_string replacements
+3. If file doesn't exist: Only then use write_file tool
+4. NEVER write over existing files unless explicitly requested by the user
+
+**Before ANY file write operation, you MUST:**
+- Confirm the file doesn't already exist by reading it first
+- If it exists, explain why you're choosing edit over write
+- If writing is necessary, explain why edit won't work
+
+For finding and searching files, prefer efficient shell commands:
+- Use 'find' with patterns: find . -name "*.js" -type f
+- Use 'grep' for text search: grep -r "function" . --include="*.ts"
+- Use 'ls' with glob patterns: ls src/**/*.ts (if supported)
+- Use 'find' + 'grep' combinations for complex searches
+- The search_files tool is available but shell commands are often faster
+
+Note that you should definitely search for patterns and keywords based on what you think you can find.
+
+Shell Command Security:
+- Safe commands (ls, find, grep, git status, cat, etc.) execute automatically
+- Other commands may require user confirmation
+- Users can approve individual commands or entire sessions
+- Running with --dangerously-accept-all skips all confirmations
+
+Shell Command Non-Interactive Mode:
+- Commands run in non-interactive mode and output is captured
+- For tools that normally prompt (npm create, git init, etc.), provide all necessary flags
+- Examples: npm create vite@latest my-app --template react (instead of letting it prompt)
+- Use --yes, --no-interactive, --template, --default flags when available
+- If a command times out or fails, check if it needs additional flags to avoid prompts
+
+## Available Tools:
+
+${generateToolDescriptions()}
+
+Be helpful, accurate, and always explain what you're doing with the files and commands.`;

package/dist/config/types.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration type definitions for ProtoAgent
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import 'dotenv/config';
+import { setToolsConfig, setToolsDangerouslyAcceptAll } from './tools/index.js';
+import { hasConfig, validateConfig, loadConfig } from './config/manager.js';
+import { setupConfig, promptReconfigure } from './config/setup.js';
+import { createOpenAIClient } from './config/client.js';
+import { showCurrentConfig, updateApiKey, updateModel, resetConfiguration } from './config/commands.js';
+import { createAgenticLoop } from './agentic-loop.js';
+import { logger, LogLevel } from './utils/logger.js';
+const program = new Command();
+// Global configuration and client
+let config = null;
+let openaiClient = null;
+let agenticLoop = null;
+program
+    .name('protoagent')
+    .description('Interactive AI coding agent CLI with file system capabilities')
+    .version('1.0.0')
+    .option('--dangerously-accept-all', 'Auto-approve all shell commands and file operations without confirmation (DANGEROUS)')
+    .option('--log-level <level>', 'Set logging level (ERROR, WARN, INFO, DEBUG, TRACE)', 'INFO');
+// Configuration management command
+program
+    .command('config')
+    .description('Manage ProtoAgent configuration')
+    .option('--show', 'Show current configuration')
+    .option('--update-key', 'Update OpenAI API key')
+    .option('--update-model', 'Update OpenAI model')
+    .option('--reset', 'Reset configuration (will prompt for new setup)')
+    .action(async (options) => {
+    if (options.show) {
+        await showCurrentConfig();
+    }
+    else if (options.updateKey) {
+        await updateApiKey();
+    }
+    else if (options.updateModel) {
+        await updateModel();
+    }
+    else if (options.reset) {
+        await resetConfiguration();
+    }
+    else {
+        console.log('Use --help to see available configuration options');
+    }
+});
+async function respondToUser(userInput) {
+    if (agenticLoop) {
+        await agenticLoop.processUserInput(userInput);
+    }
+    else {
+        console.error('❌ Agentic loop not initialized');
+    }
+}
+async function initializeConfig() {
+    // Check if configuration exists
+    if (await hasConfig()) {
+        try {
+            config = await loadConfig();
+            if (!validateConfig(config)) {
+                console.log('⚠️  Configuration is invalid or corrupted.');
+                if (await promptReconfigure()) {
+                    config = await setupConfig();
+                }
+                else {
+                    console.log('Cannot proceed without valid configuration.');
+                    process.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            console.log(`❌ Error loading configuration: ${error.message}`);
+            if (await promptReconfigure()) {
+                config = await setupConfig();
+            }
+            else {
+                console.log('Cannot proceed without valid configuration.');
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        // No configuration exists, run setup
+        config = await setupConfig();
+    }
+    // Set config for tools
+    setToolsConfig(config);
+    // Initialize OpenAI client with the configuration
+    try {
+        openaiClient = createOpenAIClient(config);
+        // Initialize the agentic loop 
+        agenticLoop = await createAgenticLoop(openaiClient, config, {
+            maxIterations: 100,
+            streamOutput: true
+        });
+        logger.debug(`✅ Successfully initialized ProtoAgent`);
+    }
+    catch (error) {
+        logger.error(`❌ Failed to initialize OpenAI client: ${error.message}`);
+        process.exit(1);
+    }
+}
+async function startInteractiveMode() {
+    console.log('🤖 Welcome to ProtoAgent - Your AI Coding Assistant with File System & Shell Powers!');
+    console.log('💡 I can read, write, edit, search files and run shell commands in your project.');
+    console.log('🔧 Ask me to create files, analyze code, run npm commands, git operations, or execute any shell command.');
+    // Check for options
+    const options = program.opts();
+    // Set log level
+    if (options.logLevel) {
+        const logLevel = LogLevel[options.logLevel.toUpperCase()];
+        if (logLevel !== undefined) {
+            logger.setLevel(logLevel);
+            logger.debug(`🔍 Log level set to: ${options.logLevel.toUpperCase()}`);
+        }
+        else {
+            logger.warn(`⚠️  Invalid log level: ${options.logLevel}. Using INFO.`);
+        }
+    }
+    // Check for dangerous flag
+    if (options.dangerouslyAcceptAll) {
+        logger.warn('⚠️  DANGER MODE: All shell commands and file operations will be auto-approved without confirmation!');
+        setToolsDangerouslyAcceptAll(true);
+    }
+    console.log('🚪 Type "exit" to quit.\n');
+    // Initialize configuration
+    await initializeConfig();
+    logger.info(`🧠 Using ${config.provider} with model: ${config.model}`);
+    // Show current working directory
+    logger.info(`📁 Working directory: ${process.cwd()}`);
+    console.log(`📁 Working directory: ${process.cwd()}\n`);
+    while (true) {
+        const { input } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'input',
+                message: 'protoagent>',
+            }
+        ]);
+        if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
+            console.log('👋 Goodbye! Happy coding!');
+            break;
+        }
+        if (input.trim() === '') {
+            continue;
+        }
+        await respondToUser(input);
+        console.log(); // Add extra newline for spacing
+    }
+}
+program
+    .action(() => {
+    startInteractiveMode();
+});
+program.parse();

package/dist/tools/create-directory.js

@@ -0,0 +1,76 @@
+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 createDirectory(dirPath) {
+    try {
+        const validPath = await validatePath(dirPath);
+        await fs.mkdir(validPath, { recursive: true });
+        return `Successfully created directory ${dirPath}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to create directory: ${error.message}`);
+        }
+        throw new Error('Failed to create directory: Unknown error');
+    }
+}
+// Tool definition
+export const createDirectoryTool = {
+    type: 'function',
+    function: {
+        name: 'create_directory',
+        description: 'Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Use this when you need to set up directory structures for projects.',
+        parameters: {
+            type: 'object',
+            properties: {
+                directory_path: {
+                    type: 'string',
+                    description: 'The path to the directory to create, relative to the current working directory. Examples: "src/components", "tests/unit", "docs"'
+                }
+            },
+            required: ['directory_path']
+        }
+    }
+};