sam-coder-cli 1.0.46 → 1.0.47

package/bin/agi-cli.js

@@ -211,11 +211,130 @@ INSTRUCTIONS:
 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.
+const FUNCTION_CALLING_PROMPT = `You are a helpful AI assistant with agency capabilities. You can perform actions on the user's system using JSON-formatted actions.
+
+AVAILABLE ACTIONS:
+1. read - Read the contents of a file
+2. write - Write content to a file  
+3. edit - Edit specific parts of a file
+4. command - Execute a shell command
+5. search - Search for files using patterns
+6. execute - Execute code (bash or node.js)
+7. analyze - Analyze code and answer questions
+8. stop - Stop taking actions and provide final response
+
+ACTION FORMAT:
+You must respond with a JSON object wrapped in markdown code blocks with the 'json' language specifier.
+The JSON should have the following structure:
+{
+  "type": "action_name",
+  "data": { /* action-specific parameters */ },
+  "reasoning": "Brief explanation of why you're taking this action"
+}
+
+EXAMPLES:
+
+To read a file:
+\`\`\`json
+{
+  "type": "read",
+  "data": {
+    "path": "path/to/file.txt"
+  },
+  "reasoning": "Reading the file to understand its current contents"
+}
+\`\`\`
+
+To write a file:
+\`\`\`json
+{
+  "type": "write",
+  "data": {
+    "path": "path/to/file.txt",
+    "content": "File content here"
+  },
+  "reasoning": "Creating a new file with the specified content"
+}
+\`\`\`
+
+To edit a file:
+\`\`\`json
+{
+  "type": "edit",
+  "data": {
+    "path": "path/to/file.txt",
+    "edits": {
+      "operations": [
+        {
+          "type": "replace",
+          "startLine": 5,
+          "endLine": 7,
+          "newText": "New content for lines 5-7"
+        }
+      ]
+    }
+  },
+  "reasoning": "Modifying specific lines in the file"
+}
+\`\`\`
+
+To run a command:
+\`\`\`json
+{
+  "type": "command",
+  "data": {
+    "command": "ls -la"
+  },
+  "reasoning": "Listing directory contents to see what files are available"
+}
+\`\`\`
+
+To search for files:
+\`\`\`json
+{
+  "type": "search",
+  "data": {
+    "type": "files",
+    "pattern": "*.js"
+  },
+  "reasoning": "Finding all JavaScript files in the current directory"
+}
+\`\`\`
+
+To execute code:
+\`\`\`json
+{
+  "type": "execute",
+  "data": {
+    "language": "bash",
+    "code": "echo 'Hello World'"
+  },
+  "reasoning": "Running a simple bash command"
+}
+\`\`\`
+
+To stop and provide final response:
+\`\`\`json
+{
+  "type": "stop",
+  "data": {},
+  "reasoning": "Task completed successfully"
+}
+\`\`\`
 
-   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.`;
+IMPORTANT RULES:
+- Always wrap your JSON in markdown code blocks with 'json' language specifier
+- Include a "reasoning" field explaining why you're taking the action
+- You will continue taking actions in a loop until you use the 'stop' action
+- Be careful with destructive operations - explain what you're doing
+- If an action fails, analyze the error and try a different approach
+- Always think step by step before taking actions
+
+ENVIRONMENT:
+- OS: ${process.platform}
+- Current directory: ${process.cwd()}
+
+Start by understanding the user's request, then take appropriate actions to fulfill it.`;
 
 // Agent utilities
 const agentUtils = {
@@ -357,26 +476,68 @@ const agentUtils = {
 
 // 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*```/;
+  if (!text || typeof text !== 'string') {
+    console.error('Invalid input to extractJsonFromMarkdown:', typeof text);
+    return null;
+  }
+
+  // Try to find a markdown code block with JSON content (case insensitive)
+  const codeBlockRegex = /```(?:json|JSON)\s*([\s\S]*?)\s*```/i;
   const match = text.match(codeBlockRegex);
   
-  if (match) {
+  if (match && match[1]) {
     try {
-      return JSON.parse(match[1]);
+      const jsonStr = match[1].trim();
+      if (!jsonStr) {
+        console.error('Empty JSON content in markdown block');
+        return null;
+      }
+      return JSON.parse(jsonStr);
     } catch (error) {
-      console.error('Error parsing JSON from markdown:', error);
+      console.error('Error parsing JSON from markdown block:', error.message);
+      console.error('JSON content was:', match[1]);
     }
   }
   
-  // If no code block, try to parse the entire text as JSON
+  // If no code block found, look for JSON-like patterns in the text
+  const jsonPatterns = [
+    // Look for objects that start with { and end with }
+    /\{[\s\S]*?\}/g,
+    // Look for arrays that start with [ and end with ]
+    /\[[\s\S]*?\]/g
+  ];
+  
+  for (const pattern of jsonPatterns) {
+    const matches = text.match(pattern);
+    if (matches) {
+      for (const match of matches) {
+        try {
+          const parsed = JSON.parse(match.trim());
+          // Validate that it looks like an action object
+          if (parsed && typeof parsed === 'object' && parsed.type) {
+            return parsed;
+          }
+        } catch (error) {
+          // Continue to next match
+          continue;
+        }
+      }
+    }
+  }
+  
+  // If still no valid JSON found, try to parse the entire text as JSON
   try {
-    return JSON.parse(text);
+    const trimmed = text.trim();
+    if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+      return JSON.parse(trimmed);
+    }
   } catch (error) {
-    console.error('Error parsing JSON:', error);
-    ui.stopThinking();
-    return null;
+    // Last resort failed
   }
+  
+  console.error('Failed to extract valid JSON from response');
+  console.error('Response text was:', text);
+  return null;
 }
 
 // Call OpenRouter API with tool calling
@@ -542,10 +703,15 @@ async function executeAction(action) {
       }
       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);
+      if (data.language === 'bash' || data.language === 'sh') {
+        return await agentUtils.runCommand(data.code);
+      } else if (data.language === 'node' || data.language === 'javascript' || data.language === 'js') {
+        // For node.js code, escape quotes properly and handle multiline code
+        const escapedCode = data.code.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+        return await agentUtils.runCommand(`node -e "${escapedCode}"`);
+      } else {
+        throw new Error(`Unsupported execution language: ${data.language}`);
+      }
     case 'browse':
       throw new Error('Web browsing is not implemented yet');
     case 'analyze':
@@ -560,44 +726,77 @@ async function executeAction(action) {
 async function processQuery(query, conversation = [], currentModel) {
   try {
     const userMessage = { role: 'user', content: query };
+    
+    // Use existing conversation (which should already have system prompt from chat function)
     let messages = [...conversation, userMessage];
+    
     let actionCount = 0;
     const MAX_ACTIONS = 10;
+    let finalResponse = '';
 
     ui.startThinking();
     
-    const responseText = await callOpenRouter(messages, currentModel, true);
-    const assistantMessage = responseText.choices[0].message;
-    messages.push(assistantMessage);
-    
-    const actionData = extractJsonFromMarkdown(assistantMessage.content);
-    
-    if (!actionData || actionData.type === 'stop') {
-      ui.stopThinking();
-      return {
-        response: assistantMessage.content,
-        conversation: messages
-      };
-    }
-
-    let currentAction = actionData;
-    while (currentAction && currentAction.type !== 'stop' && actionCount < MAX_ACTIONS) {
-      actionCount++;
-      const result = await executeAction(currentAction);
+    while (actionCount < MAX_ACTIONS) {
+      const responseObj = await callOpenRouter(messages, currentModel, true);
+      const assistantMessage = responseObj.choices[0].message;
+      messages.push(assistantMessage);
       
-      messages.push({ role: 'assistant', content: `Action result: ${result}` });
+      const actionData = extractJsonFromMarkdown(assistantMessage.content);
       
-      ui.startThinking();
-      const nextResponse = await callOpenRouter(messages, currentModel, true);
-      const nextAssistantMessage = nextResponse.choices[0].message;
-      messages.push(nextAssistantMessage);
+      // If no valid action found, treat as final response
+      if (!actionData || !actionData.type) {
+        finalResponse = assistantMessage.content;
+        break;
+      }
+      
+      // If stop action, break with the reasoning or content
+      if (actionData.type === 'stop') {
+        finalResponse = actionData.reasoning || assistantMessage.content;
+        break;
+      }
       
-      currentAction = extractJsonFromMarkdown(nextAssistantMessage.content);
+      actionCount++;
+      console.log(`🔧 Executing action ${actionCount}: ${actionData.type}`);
+      if (actionData.reasoning) {
+        console.log(`📝 Reasoning: ${actionData.reasoning}`);
+      }
+      
+      try {
+        const result = await executeAction(actionData);
+        console.log('✅ Action executed successfully');
+        
+        // Add action result to conversation
+        const resultMessage = {
+          role: 'user', 
+          content: `Action result (${actionData.type}): ${result}`
+        };
+        messages.push(resultMessage);
+        
+      } catch (error) {
+        console.error('❌ Action execution failed:', error.message);
+        
+        // Add error result to conversation
+        const errorMessage = {
+          role: 'user', 
+          content: `Action failed (${actionData.type}): ${error.message}`
+        };
+        messages.push(errorMessage);
+      }
+    }
+    
+    // If we hit max actions, get a final response
+    if (actionCount >= MAX_ACTIONS && !finalResponse) {
+      const finalMsg = { role: 'user', content: 'Please provide a final summary of what was accomplished.' };
+      messages.push(finalMsg);
+      
+      const finalResponseObj = await callOpenRouter(messages, currentModel, true);
+      finalResponse = finalResponseObj.choices[0].message.content;
+      messages.push(finalResponseObj.choices[0].message);
     }
 
     ui.stopThinking();
     return {
-      response: messages[messages.length - 1].content,
+      response: finalResponse || 'Task completed.',
       conversation: messages
     };
   } catch (error) {
@@ -613,6 +812,14 @@ async function processQuery(query, conversation = [], currentModel) {
 async function chat(rl, useToolCalling, initialModel) {
   let currentModel = initialModel;
   const conversation = [];
+  
+  // Initialize conversation with appropriate system prompt
+  if (useToolCalling) {
+    conversation.push({ role: 'system', content: TOOL_CALLING_PROMPT });
+  } else {
+    conversation.push({ role: 'system', content: FUNCTION_CALLING_PROMPT });
+  }
+  
   console.log('Type your message, or "exit" to quit.');
   
   rl.setPrompt('> ');

package/package.json

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