nothumanallowed 16.0.34 → 16.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothumanallowed",
-  "version": "16.0.34",
+  "version": "16.0.35",
   "description": "Local AI assistant: 80 tools (Gmail, Calendar, Drive, GitHub, Slack, browser, code, files), 38 agents, visual workflows (Studio, AWF, WebCraft). Install with `npm i -g nothumanallowed`, run with `nha ui`. Free tier built-in (Liara), no API key required. Your data stays on your PC — OAuth tokens local, no cloud. Open-source MIT.",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const VERSION = '16.0.34';
+export const VERSION = '16.0.35';
 export const BASE_URL = 'https://nothumanallowed.com/cli';
 export const API_BASE = 'https://nothumanallowed.com/api/v1';
 

package/src/server/routes/webcraft.mjs

@@ -1268,9 +1268,30 @@ RULES:
     );
   } else {
     // Fallback for other providers — use old text-based <tool> system
-    // (kept for backward compatibility with Gemini, DeepSeek, etc.)
+    // (kept for backward compatibility with Gemini, DeepSeek, Liara, etc.)
     let conversationHistory = [{ role: 'user', content: userContent }];
     emit({ type: 'text', token: 'Note: Using text-based tools (native tool calling not available for this provider).\n' });
+    // Inject text-based tool-format instructions into the user message so the
+    // LLM emits calls in a format the parser recognizes. The parser now ALSO
+    // accepts OpenAI/Anthropic-style nude JSON, but the wrapper form is more
+    // robust against truncation.
+    const textBasedFormat = `
+TOOL CALL FORMAT (CRITICAL):
+You MUST emit tool calls using THIS exact format (one per line, on its own line):
+
+<tool>{"op": "read", "path": "public/index.html"}</tool>
+<tool>{"op": "edit", "path": "public/index.html", "old": "exact old text", "new": "new text"}</tool>
+<tool>{"op": "write", "path": "public/css/main.css", "content": "body { ... }"}</tool>
+<tool>{"op": "check", "path": "server.js"}</tool>
+
+Valid ops: read, edit, write, delete, list, search, run, check, sandbox
+
+DO NOT write things like {"tool": "read_file", "args": {...}} — that format is for
+OpenAI-native providers, not for you. Use <tool>{"op": "read", "path": "..."}</tool>.
+
+After ALL fixes are done, emit <done/> on its own line.
+`;
+    conversationHistory[0].content = (typeof conversationHistory[0].content === 'string' ? conversationHistory[0].content : userContent) + '\n\n' + textBasedFormat;
     // Minimal old-style loop with <tool> tags — simplified
     for (let step = 0; step < MAX_STEPS; step++) {
       if (isAborted()) break;
@@ -1294,31 +1315,25 @@ RULES:
     // Check if agent signaled completion
     const isDone = stepResponse.includes('<done/>') || stepResponse.includes('<done />');
 
-    // Extract and execute ALL tool calls from this step
-    // First try matched pairs, then handle truncated (unclosed) tool tags
-    const toolRegex = /<tool>([\s\S]*?)<\/tool>/g;
-    let match;
+    // Extract and execute ALL tool calls from this step.
+    // Accept THREE wire formats (LLM providers vary wildly):
+    //   1. NHA native:    <tool>{"op":"read","path":"..."}</tool>
+    //   2. OpenAI-style:  {"tool":"read_file","args":{"file_path":"..."}}
+    //   3. Anthropic-style: <tool>{"name":"read_file","input":{"path":"..."}}</tool>
+    // Normalize all three into the internal {op, path, ...} shape before dispatch.
+    const toolCalls = _extractAllToolCalls(stepResponse);
     const toolResults = [];
-    const matchedRanges = [];
+    const matchedRanges = toolCalls.matchedRanges;
 
-    while ((match = toolRegex.exec(stepResponse)) !== null) {
-      matchedRanges.push([match.index, match.index + match[0].length]);
+    for (const rawCall of toolCalls.calls) {
       let toolCall;
       try {
-        let raw = match[1].trim();
-        raw = raw.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
-        toolCall = JSON.parse(raw);
-      } catch {
-        // LLM often puts raw HTML/code inside JSON values without proper escaping.
-        // Extract fields manually using a robust regex-based parser.
-        try {
-          toolCall = _parseToolCallRobust(match[1].trim());
-        } catch (parseErr2) {
-          console.error('[TOOL-PARSE] JSON parse failed even after robust parse:', parseErr2.message, 'raw:', match[1].slice(0, 200));
-          toolResults.push({ op: 'error', result: 'JSON parse failed' });
-          emit({ type: 'tool', op: 'parse_error', path: '', result: 'json_parse_failed' });
-          continue;
-        }
+        toolCall = _normalizeToolCall(rawCall);
+      } catch (parseErr) {
+        console.error('[TOOL-PARSE] failed:', parseErr.message, 'raw:', JSON.stringify(rawCall).slice(0, 200));
+        toolResults.push({ op: 'error', result: 'parse_failed' });
+        emit({ type: 'tool', op: 'parse_error', path: '', result: 'parse_failed' });
+        continue;
       }
 
       const { op, path: relPath, old: oldStr, new: newStr, content, newPath, query, glob: globPat, cmd } = toolCall;
@@ -3396,6 +3411,187 @@ function _safeName(name) {
  * This extracts "op", "path", "old", "new", "content", "query", "cmd" etc. by finding
  * the key-value boundaries manually.
  */
+// Map native tool names → internal NHA "op" codes. Both directions: the LLM
+// might emit either based on which provider's docs it was trained on.
+const _TOOL_NAME_TO_OP = new Map([
+  ['read_file', 'read'], ['read', 'read'],
+  ['edit_file', 'edit'], ['edit', 'edit'],
+  ['create_file', 'write'], ['write', 'write'], ['write_file', 'write'],
+  ['delete_file', 'delete'], ['delete', 'delete'],
+  ['list_files', 'list'], ['list', 'list'],
+  ['search_files', 'search'], ['search', 'search'],
+  ['run_command', 'run'], ['run', 'run'], ['shell', 'run'],
+  ['check_syntax', 'check'], ['check', 'check'],
+  ['restart_sandbox', 'sandbox'], ['sandbox', 'sandbox'],
+]);
+
+// Map common param-name variants used across LLM providers.
+const _PARAM_ALIASES = {
+  path: ['path', 'file_path', 'filepath', 'filename', 'file'],
+  old: ['old', 'old_text', 'old_string', 'oldText'],
+  new: ['new', 'new_text', 'new_string', 'newText', 'replacement'],
+  content: ['content', 'text', 'body', 'file_content'],
+  query: ['query', 'pattern', 'search', 'q'],
+  glob: ['glob', 'pattern', 'file_pattern'],
+  cmd: ['cmd', 'command', 'shell_command'],
+};
+
+function _pickParam(obj, kind) {
+  for (const alt of _PARAM_ALIASES[kind] || [kind]) {
+    if (obj && Object.prototype.hasOwnProperty.call(obj, alt) && obj[alt] !== undefined) {
+      return obj[alt];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Extract every tool-call-like JSON blob from an LLM response. Handles:
+ *   - <tool>{...}</tool>                — NHA native wrapper
+ *   - {"tool": "...", "args": {...}}    — OpenAI-style nude JSON
+ *   - {"name": "...", "input": {...}}   — Anthropic-style nude JSON
+ *   - ```json\n{...}\n```               — markdown-fenced JSON blocks
+ *
+ * Returns { calls: [raw objects], matchedRanges: [[start,end], ...] } so the
+ * caller can blank out the consumed regions from the visible text stream.
+ */
+export function _extractAllToolCalls(text) {
+  const calls = [];
+  const matchedRanges = [];
+
+  // Pass 1: <tool>...</tool> wrappers
+  const wrapRe = /<tool>([\s\S]*?)<\/tool>/g;
+  let m;
+  while ((m = wrapRe.exec(text)) !== null) {
+    matchedRanges.push([m.index, m.index + m[0].length]);
+    try {
+      let raw = m[1].trim().replace(/,\s*}/g, '}').replace(/,\s*]/g, ']');
+      calls.push(JSON.parse(raw));
+    } catch {
+      try { calls.push(_parseToolCallRobust(m[1].trim())); } catch {}
+    }
+  }
+
+  // Pass 2: markdown-fenced JSON blocks ```json {...} ```
+  const fenceRe = /```(?:json)?\s*\n([\s\S]*?)\n```/g;
+  while ((m = fenceRe.exec(text)) !== null) {
+    // Skip if already inside a <tool> match
+    if (matchedRanges.some(([s, e]) => m.index >= s && m.index < e)) continue;
+    const body = m[1].trim();
+    if (!/^\s*\{/.test(body)) continue;
+    try {
+      const parsed = JSON.parse(body.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']'));
+      if (_looksLikeToolCall(parsed)) {
+        calls.push(parsed);
+        matchedRanges.push([m.index, m.index + m[0].length]);
+      }
+    } catch {}
+  }
+
+  // Pass 3: bare JSON objects with balanced braces — scan top-level.
+  // Find every '{' candidate not already consumed, then walk forward to find
+  // the matching '}' while respecting nested braces AND string literals.
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== '{') continue;
+    if (matchedRanges.some(([s, e]) => i >= s && i < e)) continue;
+    // Must be at line start or after whitespace (avoid inline {expr}/object literals in code)
+    let prev = i - 1;
+    while (prev >= 0 && (text[prev] === ' ' || text[prev] === '\t')) prev--;
+    if (prev >= 0 && text[prev] !== '\n') continue;
+
+    const end = _findMatchingBrace(text, i);
+    if (end < 0) continue;
+    const candidate = text.slice(i, end + 1);
+    try {
+      const parsed = JSON.parse(candidate.replace(/,\s*}/g, '}').replace(/,\s*]/g, ']'));
+      if (_looksLikeToolCall(parsed)) {
+        calls.push(parsed);
+        matchedRanges.push([i, end + 1]);
+        i = end;
+      }
+    } catch {}
+  }
+
+  return { calls, matchedRanges };
+}
+
+// Walk forward from openIdx (which must be '{') to find the matching '}'.
+// Respects nested braces, string literals (single & double quote), and escapes.
+// Returns -1 if no match found (unclosed).
+function _findMatchingBrace(text, openIdx) {
+  let depth = 0;
+  let inStr = false;
+  let strCh = '';
+  for (let i = openIdx; i < text.length; i++) {
+    const c = text[i];
+    if (inStr) {
+      if (c === '\\') { i++; continue; }
+      if (c === strCh) inStr = false;
+      continue;
+    }
+    if (c === '"' || c === "'") { inStr = true; strCh = c; continue; }
+    if (c === '{') depth++;
+    else if (c === '}') {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function _looksLikeToolCall(obj) {
+  if (!obj || typeof obj !== 'object') return false;
+  return (
+    'op' in obj ||
+    'tool' in obj ||
+    'name' in obj && ('input' in obj || 'arguments' in obj || 'args' in obj) ||
+    'function_call' in obj
+  );
+}
+
+/**
+ * Normalize a parsed tool-call object to NHA's internal shape:
+ *   { op, path, old, new, content, newPath, query, glob, cmd }
+ *
+ * Accepts:
+ *   - {op, path, ...}                             — already normalized
+ *   - {tool, args: {file_path, old_text, ...}}    — OpenAI-style
+ *   - {name, input: {...}} / {name, arguments}    — Anthropic-style
+ */
+export function _normalizeToolCall(raw) {
+  if (!raw || typeof raw !== 'object') throw new Error('not an object');
+
+  // Already in NHA native shape
+  if ('op' in raw && typeof raw.op === 'string') {
+    return raw;
+  }
+
+  // Extract tool name from various wire formats
+  const toolName = raw.tool || raw.name || raw.function_call?.name;
+  if (!toolName) throw new Error('no tool/op/name field');
+
+  const op = _TOOL_NAME_TO_OP.get(toolName);
+  if (!op) throw new Error(`unknown tool name: ${toolName}`);
+
+  // Extract args payload (OpenAI uses "args", Anthropic uses "input" or "arguments")
+  let args = raw.args || raw.input || raw.arguments || raw.parameters || {};
+  if (typeof args === 'string') {
+    try { args = JSON.parse(args); } catch { args = {}; }
+  }
+
+  return {
+    op,
+    path: _pickParam(args, 'path'),
+    old: _pickParam(args, 'old'),
+    new: _pickParam(args, 'new'),
+    content: _pickParam(args, 'content'),
+    query: _pickParam(args, 'query'),
+    glob: _pickParam(args, 'glob'),
+    cmd: _pickParam(args, 'cmd'),
+    newPath: args.newPath || args.new_path,
+  };
+}
+
 function _parseToolCallRobust(raw) {
   const result = {};