sam-coder-cli 1.0.66 → 1.0.68

package/bin/agi-cli.js

@@ -418,8 +418,10 @@ You are not just executing commands - you are solving problems intelligently. Ev
 
 // Agent utilities
 const agentUtils = {
-  async readFile(filePath) {
+  async readFile(input) {
     try {
+      const filePath = typeof input === 'string' ? input : input?.path;
+      if (!filePath) throw new Error('readFile: missing path');
       const content = await fs.readFile(filePath, 'utf-8');
       return content;
     } catch (error) {
@@ -427,9 +429,12 @@ const agentUtils = {
     }
   },
 
-  async writeFile(filePath, content) {
+  async writeFile(input, maybeContent) {
     try {
-      // Ensure directory exists
+      const filePath = typeof input === 'string' ? input : input?.path;
+      const content = typeof input === 'string' ? maybeContent : input?.content;
+      if (!filePath) throw new Error('writeFile: missing path');
+      if (typeof content !== 'string') throw new Error('writeFile: missing content');
       const dir = path.dirname(filePath);
       await fs.mkdir(dir, { recursive: true });
       await fs.writeFile(filePath, content, 'utf-8');
@@ -439,10 +444,14 @@ const agentUtils = {
     }
   },
 
-  async editFile(path, edits) {
+  async editFile(inputPathOrObj, maybeEdits) {
     try {
+      const targetPath = typeof inputPathOrObj === 'string' ? inputPathOrObj : inputPathOrObj?.path;
+      const edits = typeof inputPathOrObj === 'string' ? maybeEdits : inputPathOrObj?.edits;
+      if (!targetPath) throw new Error('editFile: missing path');
+      if (!edits) throw new Error('editFile: missing edits');
       // Read the current file content
-      let content = await fs.readFile(path, 'utf-8');
+      let content = await fs.readFile(targetPath, 'utf-8');
       const lines = content.split('\n');
       
       // Process each edit operation
@@ -495,16 +504,18 @@ const agentUtils = {
       }
       
       // Write the modified content back to the file
-      await fs.writeFile(path, lines.join('\n'), 'utf-8');
-      return `Successfully edited ${path}`;
+      await fs.writeFile(targetPath, lines.join('\n'), 'utf-8');
+      return `Successfully edited ${targetPath}`;
       
     } catch (error) {
-      throw new Error(`Failed to edit file ${path}: ${error.message}`);
+      throw new Error(`Failed to edit file ${typeof inputPathOrObj === 'string' ? inputPathOrObj : inputPathOrObj?.path}: ${error.message}`);
     }
   },
 
-  async runCommand(command) {
+  async runCommand(input) {
     try {
+      const command = typeof input === 'string' ? input : input?.command;
+      if (!command) throw new Error('runCommand: missing command');
       const { stdout, stderr } = await execAsync(command, { cwd: process.cwd() });
       if (stderr) {
         console.error('Command stderr:', stderr);
@@ -515,40 +526,77 @@ const agentUtils = {
     }
   },
 
-  async searchFiles(pattern) {
+  async searchFiles(input) {
     try {
-      // Convert glob pattern to regex for Windows compatibility
-      const globToRegex = (pattern) => {
+      const isString = typeof input === 'string';
+      let pattern = isString ? input : input?.pattern;
+      let basePathRaw = isString ? null : (input?.path || null);
+      const recursive = isString ? true : (input?.recursive !== false);
+
+      // Handle wildcards embedded in the path (e.g., C:\\foo\\bar\\*)
+      const hasWildcard = (p) => typeof p === 'string' && /[\*\?]/.test(p);
+      if (!pattern && hasWildcard(basePathRaw)) {
+        pattern = path.basename(basePathRaw);
+        basePathRaw = path.dirname(basePathRaw);
+      }
+
+      const basePath = basePathRaw
+        ? (path.isAbsolute(basePathRaw) ? basePathRaw : path.join(process.cwd(), basePathRaw))
+        : process.cwd();
+
+      const results = [];
+
+      const matchByPattern = (name) => {
+        if (!pattern) return true; // if no pattern, match all
         const escaped = pattern.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
-        return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+        const regex = new RegExp('^' + escaped.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+        return regex.test(name);
       };
 
-      const regex = globToRegex(pattern);
-      const searchDir = process.cwd();
-      const results = [];
+      // If base path is a file, test it directly
+      try {
+        const stat = await fs.stat(basePath);
+        if (stat.isFile()) {
+          if (matchByPattern(path.basename(basePath))) {
+            results.push(basePath);
+          }
+          return results.length > 0
+            ? `Found ${results.length} files:\n${results.join('\n')}`
+            : 'No files found';
+        }
+      } catch (e) {
+        if (e && e.code === 'ENOENT') {
+          return 'No files found';
+        }
+        // Non-ENOENT errors are handled by traversal below
+      }
 
-      // Recursive directory search
       const search = async (dir) => {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        
+        let entries;
+        try {
+          entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch (e) {
+          if (e && e.code === 'ENOENT') return; // directory missing
+          throw e;
+        }
         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)) {
+              if (recursive) {
+                await search(fullPath);
+              }
+            } else if (matchByPattern(entry.name)) {
               results.push(fullPath);
             }
-          } catch (error) {
-            // Skip files/directories we can't access
+          } catch (_) {
             continue;
           }
         }
       };
 
-      await search(searchDir);
-      return results.length > 0 
+      await search(basePath);
+      return results.length > 0
         ? `Found ${results.length} files:\n${results.join('\n')}`
         : 'No files found';
     } catch (error) {
@@ -789,8 +837,8 @@ function parseSegmentedTranscript(text) {
 
   // If no blocks matched, return original
   if (visibleParts.length === 0 && thoughts.length === 0 && commentaryParts.length === 0) {
-    // Try channel-only segments: <|channel|>X [to=Y] [<|constrain|>Z] <|message|>... (<|end|>|<|call|>|<|return|>)
-    const chanRegex = /\<\|channel\|>\s*([a-zA-Z]+)\s*(?:to=([^\s<]+))?\s*(?:\<\|constrain\|>(\w+))?\s*\<\|message\|>([\s\S]*?)(?:\<\|end\|>|\<\|call\|>|\<\|return\|>)/gi;
+    // Try channel-only segments: allow missing trailing stop tokens; stop at next token or end
+    const chanRegex = /\<\|channel\|>\s*([a-zA-Z]+)\s*(?:to=([^\s<]+))?\s*(?:\<\|constrain\|>(\w+))?\s*\<\|message\|>([\s\S]*?)(?=(?:\<\|start\|>|\<\|channel\|>|\<\|end\|>|\<\|call\|>|\<\|return\|>|$))/gi;
     let anyChannel = false;
     let commsWithRecipients = [];
     while ((match = chanRegex.exec(text)) !== null) {
@@ -825,16 +873,8 @@ function parseSegmentedTranscript(text) {
         if (funcName.startsWith('functions.')) {
           funcName = funcName.slice('functions.'.length);
         }
-        // parse args
-        let args = {};
-        if (item.constraint === 'json' || item.body.startsWith('{') || item.body.startsWith('[')) {
-          try {
-            const parsed = JSON.parse(item.body);
-            args = parsed;
-          } catch (_) {
-            // ignore parse error; leave empty
-          }
-        }
+        // parse args (robust: try code blocks, then first JSON object)
+        let args = extractArgsJson(item.body);
         recoveredToolCalls.push({
           id: `inline-${recoveredToolCalls.length + 1}`,
           type: 'function',
@@ -882,6 +922,34 @@ function parseSegmentedTranscript(text) {
   };
 }
 
+// Extract first JSON object/array from arbitrary text, including fenced code blocks
+function extractArgsJson(text) {
+  if (!text || typeof text !== 'string') return {};
+  // Prefer fenced code block
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fence && fence[1]) {
+    try { return JSON.parse(fence[1].trim()); } catch (_) {}
+  }
+  // Try straightforward parse
+  const trimmed = text.trim();
+  if ((trimmed.startsWith('{') && trimmed.includes('}')) || (trimmed.startsWith('[') && trimmed.includes(']'))) {
+    try { return JSON.parse(trimmed); } catch (_) {}
+  }
+  // Fallback: find first {...} minimally
+  const braceRegex = /\{[\s\S]*?\}/g;
+  const m = braceRegex.exec(text);
+  if (m && m[0]) {
+    try { return JSON.parse(m[0]); } catch (_) {}
+  }
+  // Fallback: find first [...] minimally
+  const arrRegex = /\[[\s\S]*?\]/g;
+  const a = arrRegex.exec(text);
+  if (a && a[0]) {
+    try { return JSON.parse(a[0]); } catch (_) {}
+  }
+  return {};
+}
+
 // Call OpenRouter API with tool calling
 async function callOpenRouter(messages, currentModel, useJson = false) {
   const apiKey = OPENROUTER_API_KEY;
@@ -1072,7 +1140,16 @@ async function handleToolCalls(toolCalls, messages) {
         throw new Error(`Tool '${functionName}' not found`);
       }
       
-      const result = await agentUtils[functionName](...Object.values(args));
+      let result;
+      if (Array.isArray(args)) {
+        result = await agentUtils[functionName](...args);
+      } else if (args && typeof args === 'object') {
+        result = await agentUtils[functionName](args);
+      } else if (args !== undefined) {
+        result = await agentUtils[functionName](args);
+      } else {
+        result = await agentUtils[functionName]();
+      }
       console.log('✅ Tool executed successfully');
       
       const resultContent = typeof result === 'string' ? result : JSON.stringify(result);

package/package.json

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