vigthoria-cli 1.5.9 → 1.6.1

package/src/utils/tools.ts

@@ -1486,17 +1486,85 @@ export class AgenticTools {
     const calls: ToolCall[] = [];
     let match;
     
+    // Helper to extract balanced JSON from a position (handles nested braces)
+    const extractBalancedJson = (str: string, startIdx: number): string | null => {
+      if (str[startIdx] !== '{') return null;
+      let braceCount = 0;
+      let inString = false;
+      let escapeNext = false;
+      
+      for (let i = startIdx; i < str.length; i++) {
+        const char = str[i];
+        
+        if (escapeNext) {
+          escapeNext = false;
+          continue;
+        }
+        
+        if (char === '\\') {
+          escapeNext = true;
+          continue;
+        }
+        
+        if (char === '"') {
+          inString = !inString;
+          continue;
+        }
+        
+        if (!inString) {
+          if (char === '{') braceCount++;
+          else if (char === '}') {
+            braceCount--;
+            if (braceCount === 0) {
+              return str.substring(startIdx, i + 1);
+            }
+          }
+        }
+      }
+      return null;
+    };
+    
     // Helper to fix common JSON issues from AI outputs
+    // IMPORTANT: Don't blindly replace quotes - it breaks code content
     const fixJson = (jsonStr: string): string => {
-      return jsonStr
-        .replace(/'/g, '"')  // Replace single quotes with double
-        .replace(/([{,]\s*)(\w+):/g, '$1"$2":')  // Quote unquoted keys
-        .replace(/:\s*'([^']*)'\s*([,}])/g, ': "$1"$2')  // Quote values with single quotes
-        .replace(/\n/g, '\\n')  // Escape newlines
+      // First, escape newlines and control characters
+      let fixed = jsonStr
         .replace(/\r/g, '')  // Remove carriage returns
-        .replace(/\t/g, '\\t')  // Escape tabs
-        .replace(/,\s*}/g, '}')  // Remove trailing commas in objects
-        .replace(/,\s*]/g, ']');  // Remove trailing commas in arrays
+        .replace(/\t/g, '\\t');  // Escape tabs
+      
+      // Escape literal newlines inside strings (but not \n which is already escaped)
+      // We need to be careful - only escape newlines that are inside quoted strings
+      const parts: string[] = [];
+      let inString = false;
+      let currentPart = '';
+      
+      for (let i = 0; i < fixed.length; i++) {
+        const char = fixed[i];
+        const prevChar = i > 0 ? fixed[i - 1] : '';
+        
+        if (char === '"' && prevChar !== '\\') {
+          inString = !inString;
+          currentPart += char;
+        } else if (char === '\n') {
+          if (inString) {
+            currentPart += '\\n';  // Escape the newline
+          } else {
+            currentPart += char;  // Keep as-is outside strings
+          }
+        } else {
+          currentPart += char;
+        }
+      }
+      fixed = currentPart;
+      
+      // Quote unquoted keys (only outside strings)
+      fixed = fixed.replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
+      
+      // Remove trailing commas
+      fixed = fixed.replace(/,\s*}/g, '}');
+      fixed = fixed.replace(/,\s*]/g, ']');
+      
+      return fixed;
     };
 
     // Normalize tool name from various formats
@@ -1580,6 +1648,58 @@ export class AgenticTools {
       }
     }
     
+    // ROBUST PARSER: Find {"tool": at any position and extract balanced JSON
+    // This handles multi-line content in write_file and nested structures
+    const toolMarkerRegex = /\{"tool"\s*:/g;
+    while ((match = toolMarkerRegex.exec(text)) !== null) {
+      const startIdx = match.index;
+      const jsonStr = extractBalancedJson(text, startIdx);
+      
+      if (jsonStr) {
+        try {
+          const parsed = JSON.parse(jsonStr);
+          if (parsed.tool && parsed.args) {
+            parsed.tool = normalizeToolName(parsed.tool);
+            // Prevent duplicates
+            if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
+              calls.push(parsed);
+            }
+          }
+        } catch (e) {
+          // Invalid JSON, try to fix it
+          try {
+            const fixed = fixJson(jsonStr);
+            const parsed = JSON.parse(fixed);
+            if (parsed.tool && parsed.args) {
+              parsed.tool = normalizeToolName(parsed.tool);
+              if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
+                calls.push(parsed);
+              }
+            }
+          } catch (e2) {
+            // Still invalid - try more aggressive fixing for write_file
+            if (jsonStr.includes('"write_file"') || jsonStr.includes('"content"')) {
+              try {
+                // More aggressive: escape all control characters
+                const aggressiveFix = jsonStr
+                  .replace(/[\x00-\x1F]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
+                  .replace(/'/g, '"');
+                const parsed = JSON.parse(aggressiveFix);
+                if (parsed.tool && parsed.args) {
+                  parsed.tool = normalizeToolName(parsed.tool);
+                  if (!calls.some(c => c.tool === parsed.tool && JSON.stringify(c.args) === JSON.stringify(parsed.args))) {
+                    calls.push(parsed);
+                  }
+                }
+              } catch (e3) {
+                // Still invalid, skip
+              }
+            }
+          }
+        }
+      }
+    }
+    
     // Match inline JSON with "tool" key (various formats - tool before args)
     const inlineToolRegex = /\{[^{}]*"?tool"?\s*:\s*["']?([^"',}]+)["']?[^{}]*"?args"?\s*:\s*\{([^{}]*)\}[^{}]*\}/gi;
     while ((match = inlineToolRegex.exec(text)) !== null) {

package/test-parse.js

@@ -0,0 +1,105 @@
+const { AgenticTools } = require("./dist/utils/tools.js");
+
+// Test with multi-line write_file content - matching what AI actually outputs
+const text = `Here is the code I created:
+
+{"tool": "write_file", "args": {"path": "test.jsx", "content": "import React from 'react';
+
+export function Test() {
+  return <div>Hello</div>;
+}"}}
+
+And then:
+{"tool": "bash", "args": {"command": "npm test"}}
+`;
+
+console.log("Input text:");
+console.log(text);
+console.log("\n" + "=".repeat(50) + "\n");
+
+// Debug: test the balanced extractor directly
+function extractBalancedJson(str, startIdx) {
+  if (str[startIdx] !== '{') return null;
+  let braceCount = 0;
+  let inString = false;
+  let escapeNext = false;
+  
+  for (let i = startIdx; i < str.length; i++) {
+    const char = str[i];
+    
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    
+    if (char === '\\') {
+      escapeNext = true;
+      continue;
+    }
+    
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    
+    if (!inString) {
+      if (char === '{') braceCount++;
+      else if (char === '}') {
+        braceCount--;
+        if (braceCount === 0) {
+          return str.substring(startIdx, i + 1);
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function fixJson(jsonStr) {
+  return jsonStr
+    .replace(/'/g, '"')
+    .replace(/([{,]\s*)(\w+):/g, '$1"$2":')
+    .replace(/:\s*'([^']*)'\s*([,}])/g, ': "$1"$2')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '')
+    .replace(/\t/g, '\\t')
+    .replace(/,\s*}/g, '}')
+    .replace(/,\s*]/g, ']');
+}
+
+// Find the write_file call
+const regex = /\{"tool"\s*:/g;
+let match;
+while ((match = regex.exec(text)) !== null) {
+  const extracted = extractBalancedJson(text, match.index);
+  if (extracted && extracted.includes("write_file")) {
+    console.log("Extracted write_file JSON:");
+    console.log(extracted);
+    console.log("\n--- After fixJson: ---");
+    const fixed = fixJson(extracted);
+    console.log(fixed);
+    console.log("\n--- Trying to parse: ---");
+    try {
+      const parsed = JSON.parse(fixed);
+      console.log("SUCCESS:", parsed.tool);
+    } catch (e) {
+      console.log("FAILED:", e.message);
+      
+      // Try aggressive fix
+      console.log("\n--- Aggressive fix: ---");
+      const aggressive = extracted
+        .replace(/[\x00-\x1F]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
+        .replace(/'/g, '"');
+      console.log(aggressive.substring(0, 200));
+      try {
+        const parsed2 = JSON.parse(aggressive);
+        console.log("AGGRESSIVE SUCCESS:", parsed2.tool);
+      } catch (e2) {
+        console.log("AGGRESSIVE FAILED:", e2.message);
+      }
+    }
+  }
+}
+
+const calls = AgenticTools.parseToolCalls(text);
+console.log("\n\nFinal result:", calls.length, "tool calls found");

package/test-parse2.js

@@ -0,0 +1,35 @@
+const { AgenticTools } = require("./dist/utils/tools.js");
+
+// Test with complex multi-line content
+const text = `Here is the code:
+
+{"tool": "write_file", "args": {"path": "src/App.jsx", "content": "import React from 'react';
+
+function App() {
+  const [count, setCount] = useState(0);
+  
+  return (
+    <div>
+      <h1>Hello World</h1>
+      <button onClick={() => setCount(c => c + 1)}>
+        Count: {count}
+      </button>
+    </div>
+  );
+}
+
+export default App;"}}
+
+And run:
+{"tool": "bash", "args": {"command": "npm run dev"}}
+`;
+
+const calls = AgenticTools.parseToolCalls(text);
+console.log("Found", calls.length, "tool calls:");
+for (const call of calls) {
+  console.log("\n  Tool:", call.tool);
+  console.log("  Path:", call.args.path || call.args.command);
+  if (call.args.content) {
+    console.log("  Content preview:", call.args.content.substring(0, 80) + "...");
+  }
+}