sam-coder-cli 1.0.8 → 1.0.10

package/bin/agi-cli.js

@@ -12,7 +12,7 @@ const execAsync = util.promisify(exec);
 // Configuration
 const CONFIG_PATH = path.join(os.homedir(), '.sam-coder-config.json');
 let OPENROUTER_API_KEY;
-const MODEL = 'deepseek/deepseek-chat-v3-0324:free';
+let MODEL = 'deepseek/deepseek-chat-v3-0324:free';
 let API_BASE_URL = 'https://openrouter.ai/api/v1';
 
 // Tool/Function definitions for the AI
@@ -380,22 +380,21 @@ function extractJsonFromMarkdown(text) {
 }
 
 // Call OpenRouter API with tool calling
-async function callOpenRouterWithTools(messages) {
+async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
 
   try {
-    const response = await fetch(API_BASE_URL + '/chat/completions', {
+    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'
+        'Content-Type': 'application/json'
       },
       body: JSON.stringify({
-        model: MODEL,
+        model: currentModel,
         messages: messages,
-        tools: tools,
-        tool_choice: 'auto'
+        tools: useJson ? undefined : tools,
+        tool_choice: useJson ? undefined : 'auto'
       })
     });
 
@@ -415,41 +414,49 @@ async function callOpenRouterWithTools(messages) {
   }
 }
 
-// Call OpenRouter API with function calling (legacy)
-async function callOpenRouterWithFunctions(messages) {
-  const apiKey = OPENROUTER_API_KEY;
+// Process a query with tool calling
+async function processQueryWithTools(query, conversation = [], currentModel) {
+  const userMessage = { role: 'user', content: query };
+  const messages = [...conversation, userMessage];
+
+  ui.startThinking();
 
   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
-      })
-    });
+    const response = await callOpenRouter(messages, currentModel);
+    const assistantMessage = response.choices[0].message;
+    messages.push(assistantMessage);
 
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new Error('AuthenticationError: Invalid API key. Please run /setup to reconfigure.');
-      }
-      const error = await response.json();
-      throw new Error(`API error: ${error.error?.message || response.statusText}`);
-    }
+    if (assistantMessage.tool_calls) {
+      const toolResults = await handleToolCalls(assistantMessage.tool_calls, messages);
+      messages.push(...toolResults);
 
-    return await response.json();
+      ui.startThinking();
+      const finalResponseObj = await callOpenRouter(messages, currentModel);
+      const finalAssistantMessage = finalResponseObj.choices[0].message;
+      messages.push(finalAssistantMessage);
+      ui.stopThinking();
+
+      return {
+        response: finalAssistantMessage.content,
+        conversation: messages
+      };
+    } else {
+      ui.stopThinking();
+      return {
+        response: assistantMessage.content,
+        conversation: messages
+      };
+    }
   } catch (error) {
-    console.error('API call failed:', error);
     ui.stopThinking();
-    throw new Error(`Failed to call OpenRouter API: ${error.message}`);
+    ui.showError(`Error processing query: ${error.message}`);
+    return {
+      response: `Error: ${error.message}`,
+      conversation: messages
+    };
   }
 }
 
-// Process tool calls from the AI response
 async function handleToolCalls(toolCalls, messages) {
   const results = [];
   
@@ -480,7 +487,6 @@ async function handleToolCalls(toolCalls, messages) {
       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({
@@ -507,183 +513,94 @@ async function handleToolCalls(toolCalls, messages) {
   return results;
 }
 
-// Process a query with tool calling
-async function processQueryWithTools(query, conversation = []) {
-  // 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);
-    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();
-      return {
-        response: assistantMessage.content || 'No content in response',
-        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);
-    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);
-    return {
-      response: `An error occurred: ${error.message}`,
-      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, '\\"')}"`;
+        : `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 = []) {
+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);
-    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) {
     ui.stopThinking();
-    ui.showError(`Error processing query: ${error.message}`);
+    console.error('❌ Error during processing:', error);
     return {
-      response: `Error: ${error.message}`,
-      conversation: conversation || []
+      response: `An error occurred: ${error.message}`,
+      conversation: conversation
     };
   }
 }
 
-// Main chat loop
-async function chat(rl, useToolCalling) {
+async function chat(rl, useToolCalling, initialModel) {
+  let currentModel = initialModel;
   const conversation = [];
   console.log('Type your message, or "exit" to quit.');
   
@@ -691,6 +608,31 @@ async function chat(rl, useToolCalling) {
   rl.prompt();
   
   rl.on('line', async (input) => {
+    if (input.toLowerCase().startsWith('/model')) {
+      const newModel = input.split(' ')[1];
+      if (newModel) {
+        currentModel = newModel;
+        let config = await readConfig() || {};
+        config.MODEL = currentModel;
+        await writeConfig(config);
+        console.log(`Model changed to: ${currentModel}`);
+      } else {
+        console.log('Please specify a model. Usage: /model <model_name>');
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (input.toLowerCase() === '/default-model') {
+      currentModel = 'deepseek/deepseek-chat-v3-0324:free';
+      let config = await readConfig() || {};
+      config.MODEL = currentModel;
+      await writeConfig(config);
+      console.log(`Model reset to default: ${currentModel}`);
+      rl.prompt();
+      return;
+    }
+
     if (input.toLowerCase() === '/setup') {
       await runSetup(rl, true);
       console.log('\nSetup complete. Please restart the application to apply changes.');
@@ -704,13 +646,12 @@ async function chat(rl, useToolCalling) {
     }
     
     const result = useToolCalling 
-      ? await processQueryWithTools(input, conversation)
-      : await processQuery(input, conversation);
+      ? await processQueryWithTools(input, conversation, currentModel)
+      : await processQuery(input, conversation, currentModel);
     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();
@@ -720,7 +661,6 @@ async function chat(rl, useToolCalling) {
   });
 }
 
-// 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) => {
@@ -729,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;
   }
@@ -783,7 +722,6 @@ async function runSetup(rl, isReconfig = false) {
   return config;
 }
 
-// Start the application
 async function start() {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -796,6 +734,8 @@ async function start() {
       config = await runSetup(rl);
     }
 
+    MODEL = config.MODEL || 'deepseek/deepseek-chat-v3-0324:free';
+
     OPENROUTER_API_KEY = config.OPENROUTER_API_KEY;
     if (config.isPro && config.customApiBase) {
       API_BASE_URL = config.customApiBase;
@@ -810,8 +750,7 @@ 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);
+    await chat(rl, useToolCalling, MODEL);
   } catch (error) {
     ui.showError(error);
     rl.close();
@@ -819,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.8",
+  "version": "1.0.10",
   "description": "SAM-CODER: An animated command-line AI assistant with agency capabilities.",
   "main": "bin/agi-cli.js",
   "bin": {