sam-coder-cli 1.0.0

package/bin/agi-cli.js

@@ -0,0 +1,815 @@
+#!/usr/bin/env node
+
+const ui = require('./ui.js');
+const readline = require('readline');
+const path = require('path');
+const fs = require('fs').promises;
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
+
+// Configuration
+const CONFIG_PATH = path.join(__dirname, 'config.json');
+let OPENROUTER_API_KEY;
+const MODEL = 'deepseek/deepseek-chat-v3-0324:free';
+const API_BASE_URL = 'https://openrouter.ai/api/v1';
+
+// Tool/Function definitions for the AI
+const tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'readFile',
+      description: 'Read the contents of a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path to the file to read' }
+        },
+        required: ['path']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'writeFile',
+      description: 'Write content to a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path to the file to write' },
+          content: { type: 'string', description: 'Content to write to the file' }
+        },
+        required: ['path', 'content']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'editFile',
+      description: 'Edit specific parts of a file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path to the file to edit' },
+          edits: {
+            type: 'object',
+            properties: {
+              operations: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    type: { 
+                      type: 'string', 
+                      enum: ['replace', 'insert', 'delete'],
+                      description: 'Type of edit operation'
+                    },
+                    startLine: { 
+                      type: 'number', 
+                      description: 'Starting line number (1-based)' 
+                    },
+                    endLine: { 
+                      type: 'number', 
+                      description: 'Ending line number (1-based, inclusive)' 
+                    },
+                    newText: { 
+                      type: 'string', 
+                      description: 'New text to insert or replace with' 
+                    },
+                    pattern: { 
+                      type: 'string', 
+                      description: 'Pattern to search for (for replace operations)' 
+                    },
+                    replacement: { 
+                      type: 'string', 
+                      description: 'Replacement text (for pattern-based replace)' 
+                    },
+                    flags: { 
+                      type: 'string', 
+                      description: 'Regex flags (e.g., "g" for global)' 
+                    },
+                    position: { 
+                      type: 'string', 
+                      enum: ['start', 'end'],
+                      description: 'Where to insert (only for insert operations)' 
+                    },
+                    line: { 
+                      type: 'number', 
+                      description: 'Line number to insert at (for line-based insert)' 
+                    }
+                  },
+                  required: ['type'],
+                  oneOf: [
+                    {
+                      properties: {
+                        type: { const: 'replace' },
+                        startLine: { type: 'number' },
+                        endLine: { type: 'number' },
+                        newText: { type: 'string' }
+                      },
+                      required: ['startLine', 'endLine', 'newText']
+                    },
+                    {
+                      properties: {
+                        type: { const: 'replace' },
+                        pattern: { type: 'string' },
+                        replacement: { type: 'string' },
+                        flags: { type: 'string' }
+                      },
+                      required: ['pattern', 'replacement']
+                    },
+                    {
+                      properties: {
+                        type: { const: 'insert' },
+                        position: { type: 'string', enum: ['start', 'end'] },
+                        text: { type: 'string' }
+                      },
+                      required: ['position', 'text']
+                    },
+                    {
+                      properties: {
+                        type: { const: 'insert' },
+                        line: { type: 'number' },
+                        text: { type: 'string' }
+                      },
+                      required: ['line', 'text']
+                    },
+                    {
+                      properties: {
+                        type: { const: 'delete' },
+                        startLine: { type: 'number' },
+                        endLine: { type: 'number' }
+                      },
+                      required: ['startLine', 'endLine']
+                    }
+                  ]
+                }
+              }
+            },
+            required: ['operations']
+          }
+        },
+        required: ['path', 'edits']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'runCommand',
+      description: 'Execute a shell command',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Command to execute' }
+        },
+        required: ['command']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'searchFiles',
+      description: 'Search for files using a glob pattern',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Glob pattern to search for' }
+        },
+        required: ['pattern']
+      }
+    }
+  }
+];
+
+// System prompt for the AI Assistant when using tool calling
+const TOOL_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system using the provided tools.
+
+TOOLS AVAILABLE:
+1. readFile - Read the contents of a file
+2. writeFile - Write content to a file
+3. editFile - Edit specific parts of a file
+4. runCommand - Execute a shell command
+5. searchFiles - Search for files using a glob pattern
+
+ENVIRONMENT:
+- OS: ${process.platform}
+- Current directory: ${process.cwd()}
+
+INSTRUCTIONS:
+- Use the provided tools to accomplish the user's request
+- Be concise but thorough in your responses
+- When executing commands or making changes, explain what you're doing
+- If you're unsure about a command or action, ask for clarification
+- Be careful with destructive operations - warn before making changes
+
+Always think step by step and explain your reasoning before taking actions that could affect the system.`;
+
+// System prompt for the AI Assistant when using legacy function calling (JSON actions)
+const FUNCTION_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system.
+
+   By default, you will continue to take actions in a loop until you decide to stop with the 'stop' action type.
+   Always wrap your JSON in markdown code blocks with the json language specifier.
+   When executing code or commands that might be potentially harmful, explain what the code does before executing it.`;
+
+// Agent utilities
+const agentUtils = {
+  async readFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+    }
+  },
+
+  async writeFile(filePath, content) {
+    try {
+      await fs.writeFile(filePath, content, 'utf-8');
+      return `Successfully wrote to ${filePath}`;
+    } catch (error) {
+      throw new Error(`Failed to write to file ${filePath}: ${error.message}`);
+    }
+  },
+
+  async editFile(path, edits) {
+    try {
+      // Read the current file content
+      let content = await fs.readFile(path, 'utf-8');
+      const lines = content.split('\n');
+      
+      // Process each edit operation
+      for (const op of edits.operations) {
+        switch (op.type) {
+          case 'replace':
+            if (op.startLine !== undefined && op.endLine !== undefined) {
+              // Line-based replacement
+              if (op.startLine < 1 || op.endLine > lines.length) {
+                throw new Error(`Line numbers out of range (1-${lines.length})`);
+              }
+              const before = lines.slice(0, op.startLine - 1);
+              const after = lines.slice(op.endLine);
+              const newLines = op.newText.split('\n');
+              lines.splice(0, lines.length, ...before, ...newLines, ...after);
+            } else if (op.pattern) {
+              // Pattern-based replacement
+              const regex = new RegExp(op.pattern, op.flags || '');
+              content = content.replace(regex, op.replacement);
+              // Update lines array for subsequent operations
+              lines.length = 0;
+              lines.push(...content.split('\n'));
+            }
+            break;
+            
+          case 'insert':
+            if (op.position === 'start') {
+              lines.unshift(...op.text.split('\n'));
+            } else if (op.position === 'end') {
+              lines.push(...op.text.split('\n'));
+            } else if (op.line !== undefined) {
+              if (op.line < 1 || op.line > lines.length + 1) {
+                throw new Error(`Line number out of range (1-${lines.length + 1})`);
+              }
+              const insertLines = op.text.split('\n');
+              lines.splice(op.line - 1, 0, ...insertLines);
+            }
+            break;
+            
+          case 'delete':
+            if (op.startLine < 1 || op.endLine > lines.length) {
+              throw new Error(`Line numbers out of range (1-${lines.length})`);
+            }
+            lines.splice(op.startLine - 1, op.endLine - op.startLine + 1);
+            break;
+            
+          default:
+            throw new Error(`Unknown operation type: ${op.type}`);
+        }
+      }
+      
+      // Write the modified content back to the file
+      await fs.writeFile(path, lines.join('\n'), 'utf-8');
+      return `Successfully edited ${path}`;
+      
+    } catch (error) {
+      throw new Error(`Failed to edit file ${path}: ${error.message}`);
+    }
+  },
+
+  async runCommand(command) {
+    try {
+      const { stdout, stderr } = await execAsync(command, { cwd: process.cwd() });
+      if (stderr) {
+        console.error('Command stderr:', stderr);
+      }
+      return stdout || 'Command executed successfully (no output)';
+    } catch (error) {
+      throw new Error(`Command failed: ${error.message}`);
+    }
+  },
+
+  async searchFiles(pattern) {
+    try {
+      // Convert glob pattern to regex for Windows compatibility
+      const globToRegex = (pattern) => {
+        const escaped = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+        return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+      };
+
+      const regex = globToRegex(pattern);
+      const searchDir = process.cwd();
+      const results = [];
+
+      // Recursive directory search
+      const search = async (dir) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          
+          try {
+            if (entry.isDirectory()) {
+              await search(fullPath);
+            } else if (regex.test(entry.name)) {
+              results.push(fullPath);
+            }
+          } catch (error) {
+            // Skip files/directories we can't access
+            continue;
+          }
+        }
+      };
+
+      await search(searchDir);
+      return results.length > 0 
+        ? `Found ${results.length} files:\n${results.join('\n')}`
+        : 'No files found';
+    } catch (error) {
+      throw new Error(`Search failed: ${error.message}`);
+    }
+  }
+};
+
+// Extract JSON from markdown code blocks
+function extractJsonFromMarkdown(text) {
+  // Try to find a markdown code block with JSON content
+  const codeBlockRegex = /```json\s*([\s\S]*?)\s*```/;
+  const match = text.match(codeBlockRegex);
+  
+  if (match) {
+    try {
+      return JSON.parse(match[1]);
+    } catch (error) {
+      console.error('Error parsing JSON from markdown:', error);
+    }
+  }
+  
+  // If no code block, try to parse the entire text as JSON
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    console.error('Error parsing JSON:', error);
+    ui.stopThinking();
+    return null;
+  }
+}
+
+// Call OpenRouter API with tool calling
+async function callOpenRouterWithTools(messages) {
+  const apiKey = OPENROUTER_API_KEY;
+
+  try {
+    const response = await fetch(API_BASE_URL + '/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'HTTP-Referer': 'https://github.com/yourusername/agi-cli'
+      },
+      body: JSON.stringify({
+        model: MODEL,
+        messages: messages,
+        tools: tools,
+        tool_choice: 'auto'
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`API error: ${error.error?.message || response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error('API call failed:', error);
+    ui.stopThinking();
+    throw new Error(`Failed to call OpenRouter API: ${error.message}`);
+  }
+}
+
+// Call OpenRouter API with function calling (legacy)
+async function callOpenRouterWithFunctions(messages) {
+  const apiKey = OPENROUTER_API_KEY;
+
+  try {
+    const response = await fetch(API_BASE_URL + '/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'HTTP-Referer': 'https://github.com/yourusername/agi-cli'
+      },
+      body: JSON.stringify({
+        model: MODEL,
+        messages: messages
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`API error: ${error.error?.message || response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error('API call failed:', error);
+    ui.stopThinking();
+    throw new Error(`Failed to call OpenRouter API: ${error.message}`);
+  }
+}
+
+// Process tool calls from the AI response
+async function handleToolCalls(toolCalls, messages) {
+  const results = [];
+  
+  for (const toolCall of toolCalls) {
+    const functionName = toolCall.function.name;
+    let args;
+    
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch (error) {
+      console.error('❌ Failed to parse tool arguments:', error);
+      results.push({
+        tool_call_id: toolCall.id,
+        role: 'tool',
+        name: functionName,
+        content: JSON.stringify({ error: `Invalid arguments format: ${error.message}` })
+      });
+      continue;
+    }
+    
+    console.log(`🔧 Executing ${functionName} with args:`, args);
+    
+    try {
+      if (!agentUtils[functionName]) {
+        throw new Error(`Tool '${functionName}' not found`);
+      }
+      
+      const result = await agentUtils[functionName](...Object.values(args));
+      console.log('✅ Tool executed successfully');
+      
+      // Stringify the result if it's not already a string
+      const resultContent = typeof result === 'string' ? result : JSON.stringify(result);
+      
+      results.push({
+        tool_call_id: toolCall.id,
+        role: 'tool',
+        name: functionName,
+        content: resultContent
+      });
+    } catch (error) {
+      console.error('❌ Tool execution failed:', error);
+      
+      results.push({
+        tool_call_id: toolCall.id,
+        role: 'tool',
+        name: functionName,
+        content: JSON.stringify({ 
+          error: error.message,
+          stack: process.env.DEBUG ? error.stack : undefined
+        })
+      });
+    }
+  }
+  
+  return results;
+}
+
+// Process a query with tool calling
+async function processQueryWithTools(query, conversation = [], maxIterations = 5) {
+  // Add user message to conversation
+  const userMessage = { role: 'user', content: query };
+  let messages = [...conversation, userMessage];
+  let iteration = 0;
+  let finalResponse = null;
+
+  // Add system message if this is the first message
+  if (conversation.length === 0) {
+    messages.unshift({
+      role: 'system',
+      content: `You are a helpful AI assistant with access to tools. Use the tools when needed.
+You can use multiple tools in sequence if needed to complete the task.
+When using tools, make sure to provide all required parameters.
+If a tool fails, you can try again with different parameters or a different approach.`
+    });
+  }
+
+  // Process in a loop to handle multiple tool calls
+  while (iteration < maxIterations) {
+    ui.startThinking();
+    
+    try {
+      const response = await callOpenRouterWithTools(messages);
+      const assistantMessage = response.choices[0].message;
+      messages.push(assistantMessage);
+      
+      // If there are no tool calls, we're done
+      if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
+        ui.stopThinking();
+        finalResponse = assistantMessage.content || 'No content in response';
+        break;
+      }
+      
+      // Process tool calls
+      console.log(`🛠️  Executing ${assistantMessage.tool_calls.length} tools...`);
+      const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
+      
+      // Add tool results to messages
+      messages = [...messages, ...toolResults];
+      
+      // If we've reached max iterations, get a final response
+      if (iteration === maxIterations - 1) {
+        console.log('ℹ️  Reached maximum number of iterations. Getting final response...');
+        const finalResponseObj = await callOpenRouterWithTools(messages);
+        finalResponse = finalResponseObj.choices[0].message.content || 'No content in final response';
+      }
+      
+      iteration++;
+    } catch (error) {
+      ui.stopThinking();
+      console.error('❌ Error during processing:', error);
+      finalResponse = `An error occurred: ${error.message}`;
+      break;
+    }
+  }
+  
+  // If we don't have a final response yet (shouldn't happen, but just in case)
+  if (!finalResponse) {
+    finalResponse = 'No response generated. The operation may have timed out or encountered an error.';
+  }
+  
+  return {
+    response: finalResponse,
+    conversation: messages
+  };
+}
+
+// Execute a single action from the action system
+async function executeAction(action) {
+  const { type, data } = action;
+  
+  switch (type) {
+    case 'read':
+      return await agentUtils.readFile(data.path);
+      
+    case 'write':
+      return await agentUtils.writeFile(data.path, data.content);
+      
+    case 'edit':
+      return await agentUtils.editFile(data.path, data.edits);
+      
+    case 'command':
+      return await agentUtils.runCommand(data.command);
+      
+    case 'search':
+      if (data.type === 'files') {
+        return await agentUtils.searchFiles(data.pattern);
+      }
+      throw new Error('Text search is not implemented yet');
+      
+    case 'execute':
+      // For execute action, we'll run it as a command
+      const cmd = data.language === 'bash' 
+        ? data.code 
+        : `node -e "${data.code.replace(/"/g, '\\"')}"`;
+      return await agentUtils.runCommand(cmd);
+      
+    case 'browse':
+      throw new Error('Web browsing is not implemented yet');
+      
+    case 'analyze':
+      // For analyze action, we'll just return the question for now
+      return `Analysis requested for code: ${data.code}\nQuestion: ${data.question}`;
+      
+    case 'stop':
+      return 'Stopping action execution';
+      
+    default:
+      throw new Error(`Unknown action type: ${type}`);
+  }
+}
+
+// Process a query with action handling (legacy function calling)
+async function processQuery(query, conversation = []) {
+  try {
+    // Add user message to conversation
+    const userMessage = { role: 'user', content: query };
+    const messages = [...conversation, userMessage];
+
+    // Add system message if this is the first message
+    if (conversation.length === 0) {
+      messages.unshift({
+        role: 'system',
+        content: FUNCTION_CALLING_PROMPT
+      });
+    }
+
+    ui.startThinking();
+    
+    const response = await callOpenRouterWithFunctions(messages);
+    const assistantMessage = response.choices[0].message;
+    messages.push(assistantMessage);
+    
+    // Try to extract JSON from the response
+    const actionData = extractJsonFromMarkdown(assistantMessage.content);
+    
+    if (actionData && actionData.actions) {
+      ui.stopThinking();
+      ui.showAction('Executing actions...');
+      const results = [];
+      
+      for (const action of actionData.actions) {
+        ui.showAction(`  → ${action.type} action`);
+        try {
+          const result = await executeAction(action);
+          results.push({ type: action.type, success: true, result });
+        } catch (error) {
+          results.push({ type: action.type, success: false, error: error.message });
+        }
+      }
+      
+      // Add action results to the conversation
+      messages.push({
+        role: 'system',
+        content: `Action results: ${JSON.stringify(results, null, 2)}`
+      });
+      
+      // Continue the conversation with the results
+      return {
+        response: `Actions executed. Results: ${JSON.stringify(results, null, 2)}`,
+        conversation: messages
+      };
+    }
+    
+    ui.stopThinking();
+    return {
+      response: assistantMessage.content || 'No content in response',
+      conversation: messages
+    };
+  } catch (error) {
+    ui.stopThinking();
+    ui.showError(`Error processing query: ${error.message}`);
+    return {
+      response: `Error: ${error.message}`,
+      conversation: conversation || []
+    };
+  }
+}
+
+// Main chat loop
+async function chat(useToolCalling) {
+  const conversation = [];
+  ui.showHeader();
+  console.log('Type your message, or "exit" to quit.');
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '> '
+  });
+  
+  rl.prompt();
+  
+  rl.on('line', async (input) => {
+    if (input.toLowerCase() === '/setup') {
+      await runSetup(true);
+      console.log('\nSetup complete. Please restart the application to apply changes.');
+      rl.close();
+      return;
+    }
+
+    if (input.toLowerCase() === 'exit') {
+      rl.close();
+      return;
+    }
+    
+    const result = useToolCalling 
+      ? await processQueryWithTools(input, conversation)
+      : await processQuery(input, conversation);
+    ui.stopThinking();
+    ui.showResponse(result.response);
+    
+    // Update conversation with the full context
+    conversation.length = 0; // Clear the array
+    result.conversation.forEach(msg => conversation.push(msg));
+    
+    rl.prompt();
+  }).on('close', () => {
+    ui.showResponse('Goodbye!');
+    process.exit(0);
+  });
+}
+
+// Ask user for mode selection
+function askForMode() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question('Select mode (1 for tool calling, 2 for function calling): ', (answer) => {
+      rl.close();
+      resolve(answer.trim() === '1');
+    });
+  });
+}
+
+// Start the application
+async function readConfig() {
+  try {
+    const data = await fs.readFile(CONFIG_PATH, 'utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return null; // Config file doesn't exist
+    }
+    throw error;
+  }
+}
+
+async function writeConfig(config) {
+  await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+async function runSetup(isReconfig = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const askQuestion = (query) => new Promise(resolve => rl.question(query, resolve));
+
+  if (!isReconfig) {
+    ui.showHeader();
+    console.log('Welcome to SAM-CODER Setup!');
+    console.log('Please provide your OpenRouter API key to get started.');
+  } else {
+    console.log('\n--- Re-running Setup ---');
+  }
+
+  const apiKey = await askQuestion('Enter OpenRouter API Key: ');
+
+  const config = { OPENROUTER_API_KEY: apiKey };
+  await writeConfig(config);
+
+  console.log('✅ Configuration saved successfully!');
+  rl.close();
+  return config;
+}
+
+// Start the application
+async function start() {
+  try {
+    let config = await readConfig();
+    if (!config || !config.OPENROUTER_API_KEY) {
+      config = await runSetup();
+      console.log('\nSetup complete. Please start the application again.');
+      process.exit(0);
+    }
+
+    OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
+
+    ui.showHeader();
+    console.log('Select Mode:');
+    console.log('1. Tool Calling (for models that support it)');
+    console.log('2. Function Calling (legacy)');
+    
+    const useToolCalling = await askForMode();
+    ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
+    
+    // Start the chat with the selected mode
+    await chat(useToolCalling);
+  } catch (error) {
+    ui.showError(error);
+    process.exit(1);
+  }
+}
+
+// Start the application
+start().catch(console.error);