sam-coder-cli 1.0.9 → 1.0.10

package/bin/agi-cli.js

@@ -387,14 +387,14 @@ async function callOpenRouter(messages, currentModel, useJson = false) {
     const response = await fetch(`${API_BASE_URL}/chat/completions`, {
       method: 'POST',
       headers: {
-        'Authorization': `Bearer ${OPENROUTER_API_KEY}`,
+        'Authorization': `Bearer ${apiKey}`,
         'Content-Type': 'application/json'
       },
       body: JSON.stringify({
         model: currentModel,
         messages: messages,
-        tools: tools,
-        tool_choice: 'auto'
+        tools: useJson ? undefined : tools,
+        tool_choice: useJson ? undefined : 'auto'
       })
     });
 
@@ -416,122 +416,177 @@ async function callOpenRouter(messages, currentModel, useJson = false) {
 
 // Process a query with tool calling
 async function processQueryWithTools(query, conversation = [], currentModel) {
-  // 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: `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.`
-    });
-  }
-
   ui.startThinking();
 
   try {
-    const response = await callOpenRouterWithTools(messages, currentModel);
+    const response = await callOpenRouter(messages, currentModel);
     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) {
+    if (assistantMessage.tool_calls) {
+      const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
+      messages.push(...toolResults);
+
+      ui.startThinking();
+      const finalResponseObj = await callOpenRouter(messages, currentModel);
+      const finalAssistantMessage = finalResponseObj.choices[0].message;
+      messages.push(finalAssistantMessage);
       ui.stopThinking();
+
       return {
-        response: assistantMessage.content || 'No content in response',
+        response: finalAssistantMessage.content,
+        conversation: messages
+      };
+    } else {
+      ui.stopThinking();
+      return {
+        response: assistantMessage.content,
         conversation: messages
       };
     }
-
-    // Process tool calls
-    ui.stopThinking(); // Stop thinking while tools execute
-    console.log(`🛠️  Executing ${assistantMessage.tool_calls.length} tools...`);
-    const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
-
-    // Add tool results to messages
-    messages.push(...toolResults);
-
-    // Now, get the AI's response to the tool results
-    ui.startThinking();
-    const finalResponseObj = await callOpenRouterWithTools(messages, currentModel);
-    const finalAssistantMessage = finalResponseObj.choices[0].message;
-    messages.push(finalAssistantMessage);
-    ui.stopThinking();
-
-    return {
-      response: finalAssistantMessage.content || 'Actions executed. What is the next step?',
-      conversation: messages
-    };
-
   } catch (error) {
     ui.stopThinking();
-    console.error('❌ Error during processing:', error);
+    ui.showError(`Error processing query: ${error.message}`);
     return {
-      response: `An error occurred: ${error.message}`,
+      response: `Error: ${error.message}`,
       conversation: messages
     };
   }
 }
 
-// Process a query with action handling (legacy function calling)
+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');
+      
+      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;
+}
+
+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':
+      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':
+      return `Analysis requested for code: ${data.code}\nQuestion: ${data.question}`;
+    case 'stop':
+      return 'Stopping action execution';
+    default:
+      throw new Error(`Unknown action type: ${type}`);
+  }
+}
+
 async function processQuery(query, conversation = [], currentModel) {
   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
-      });
-    }
+    let messages = [...conversation, userMessage];
+    let actionCount = 0;
+    const MAX_ACTIONS = 10;
 
     ui.startThinking();
     
-    const response = await callOpenRouterWithFunctions(messages, currentModel);
-    const assistantMessage = response.choices[0].message;
+    const responseText = await callOpenRouter(messages, currentModel, true);
+    const assistantMessage = responseText.choices[0].message;
     messages.push(assistantMessage);
-
-    // Try to extract JSON from the response
+    
     const actionData = extractJsonFromMarkdown(assistantMessage.content);
     
-    if (actionData && actionData.actions) {
+    if (!actionData || actionData.type === 'stop') {
       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)}`,
+        response: assistantMessage.content,
         conversation: messages
       };
     }
-    
+
+    let currentAction = actionData;
+    while (currentAction && currentAction.type !== 'stop' && actionCount < MAX_ACTIONS) {
+      actionCount++;
+      const result = await executeAction(currentAction);
+      
+      messages.push({ role: 'assistant', content: `Action result: ${result}` });
+      
+      ui.startThinking();
+      const nextResponse = await callOpenRouter(messages, currentModel, true);
+      const nextAssistantMessage = nextResponse.choices[0].message;
+      messages.push(nextAssistantMessage);
+      
+      currentAction = extractJsonFromMarkdown(nextAssistantMessage.content);
+    }
+
     ui.stopThinking();
     return {
-      response: assistantMessage.content || 'No content in response',
+      response: messages[messages.length - 1].content,
       conversation: messages
     };
   } catch (error) {
@@ -539,12 +594,11 @@ async function processQuery(query, conversation = [], currentModel) {
     console.error('❌ Error during processing:', error);
     return {
       response: `An error occurred: ${error.message}`,
-      conversation: messages
+      conversation: conversation
     };
   }
 }
 
-// Main chat loop
 async function chat(rl, useToolCalling, initialModel) {
   let currentModel = initialModel;
   const conversation = [];
@@ -558,7 +612,7 @@ async function chat(rl, useToolCalling, initialModel) {
       const newModel = input.split(' ')[1];
       if (newModel) {
         currentModel = newModel;
-        let config = await readConfig();
+        let config = await readConfig() || {};
         config.MODEL = currentModel;
         await writeConfig(config);
         console.log(`Model changed to: ${currentModel}`);
@@ -571,7 +625,7 @@ async function chat(rl, useToolCalling, initialModel) {
 
     if (input.toLowerCase() === '/default-model') {
       currentModel = 'deepseek/deepseek-chat-v3-0324:free';
-      let config = await readConfig();
+      let config = await readConfig() || {};
       config.MODEL = currentModel;
       await writeConfig(config);
       console.log(`Model reset to default: ${currentModel}`);
@@ -597,8 +651,7 @@ async function chat(rl, useToolCalling, initialModel) {
     ui.stopThinking();
     ui.showResponse(result.response);
     
-    // Update conversation with the full context
-    conversation.length = 0; // Clear the array
+    conversation.length = 0;
     result.conversation.forEach(msg => conversation.push(msg));
     
     rl.prompt();
@@ -608,7 +661,6 @@ async function chat(rl, useToolCalling, initialModel) {
   });
 }
 
-// Ask user for mode selection
 function askForMode(rl) {
   return new Promise((resolve) => {
     rl.question('Select mode (1 for tool calling, 2 for function calling): ', (answer) => {
@@ -617,14 +669,13 @@ function askForMode(rl) {
   });
 }
 
-// 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
+      return null;
     }
     throw error;
   }
@@ -671,7 +722,6 @@ async function runSetup(rl, isReconfig = false) {
   return config;
 }
 
-// Start the application
 async function start() {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -684,42 +734,7 @@ async function start() {
       config = await runSetup(rl);
     }
 
-    MODEL = config.MODEL || 'deepseek/deepseek-chat-v3-0324:free'; // Load model from config or use default
-
-    OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
-    if (config.isPro && config.customApiBase) {
-      API_BASE_URL = config.customApiBase;
-      console.log(`🚀 Using Pro Plan custom endpoint: ${API_BASE_URL}`);
-    }
-
-    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(rl);
-    ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
-    
-    // Start the chat with the selected mode
-    await chat(rl, useToolCalling, MODEL);
-  } catch (error) {
-    ui.showError(error);
-    rl.close();
-    process.exit(1);
-  }
-}
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  try {
-    let config = await readConfig();
-    if (!config || !config.OPENROUTER_API_KEY) {
-      config = await runSetup(rl);
-    }
-
-    MODEL = config.MODEL || 'deepseek/deepseek-chat-v3-0324:free'; // Load model from config or use default
+    MODEL = config.MODEL || 'deepseek/deepseek-chat-v3-0324:free';
 
     OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
     if (config.isPro && config.customApiBase) {
@@ -735,7 +750,6 @@ async function start() {
     const useToolCalling = await askForMode(rl);
     ui.showResponse(`\nStarting in ${useToolCalling ? 'Tool Calling' : 'Function Calling'} mode...\n`);
     
-    // Start the chat with the selected mode
     await chat(rl, useToolCalling, MODEL);
   } catch (error) {
     ui.showError(error);
@@ -744,5 +758,4 @@ async function start() {
   }
 }
 
-// Start the application
 start().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sam-coder-cli",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {