@krmxd/onegpt 2.0.0-beta.1

package/src/tools.js

@@ -0,0 +1,1119 @@
+"use strict";
+
+// Tools registry and permission system - full parity with the Python build:
+// alias resolution, argument repair/anchoring, schema validation with teaching
+// errors, permission prompts only for genuinely dangerous tools, Google-first
+// web search with TLS fallback.
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const http = require("http");
+const https = require("https");
+const { spawnSync } = require("child_process");
+
+class ToolDef {
+  constructor(name, description, parameters, dangerous = false) {
+    this.name = name;
+    this.description = description;
+    this.parameters = parameters;
+    this.dangerous = dangerous;
+    this.run = async () => new ToolResult("", "Not implemented", false);
+  }
+}
+
+class ToolResult {
+  constructor(output = "", error = "", success = true) {
+    this.output = output;
+    this.error = error;
+    this.success = success;
+    this.toolCallId = "";
+    this.name = "";
+  }
+
+  get content() {
+    return this.success ? this.output : `Error: ${this.error}`;
+  }
+}
+
+const IGNORE = new Set([".git", "node_modules", "__pycache__", ".venv", "venv",
+  ".tox", "dist", "build", "target", "vendor"]);
+
+function hsz(n) {
+  let s = n;
+  for (const u of ["B", "KB", "MB", "GB"]) {
+    if (s < 1024) return u === "B" ? `${Math.round(s)}${u}` : `${s.toFixed(1)}${u}`;
+    s /= 1024;
+  }
+  return `${s.toFixed(1)}TB`;
+}
+
+// ---------------------------------------------------------------------------
+// Small local models constantly invent tool names ("create_file", "mkdir",
+// "run_command"...) or misname arguments ("filename", "text"). Hard-rejecting
+// them breaks the whole flow with 'Unknown tool'. Instead we resolve aliases
+// and repair arguments so the intended action still runs.
+const TOOL_ALIASES = {
+  // folder creation
+  mkdir: "make_dir", makedir: "make_dir", createdir: "make_dir", create_dir: "make_dir",
+  create_directory: "make_dir", newdir: "make_dir", new_dir: "make_dir",
+  newfolder: "make_dir", new_folder: "make_dir", createfolder: "make_dir",
+  create_folder: "make_dir", folder: "make_dir", directory: "make_dir",
+  // file writing
+  writefile: "write_file", filewrite: "write_file", createfile: "write_file",
+  create_file: "write_file", newfile: "write_file", new_file: "write_file",
+  savefile: "write_file", save_file: "write_file", save: "write_file",
+  touch: "write_file", overwritefile: "write_file", overwrite_file: "write_file",
+  // file reading
+  readfile: "read_file", cat: "read_file", openfile: "read_file",
+  viewfile: "read_file", showfile: "read_file", view: "read_file",
+  // editing
+  editfile: "edit_file", edit: "edit_file", replace: "edit_file",
+  replacetext: "edit_file", replace_text: "edit_file", strreplace: "edit_file",
+  str_replace: "edit_file", patch: "edit_file", patchfile: "edit_file",
+  patch_file: "edit_file", updatefile: "edit_file", update_file: "edit_file",
+  modifyfile: "edit_file", modify_file: "edit_file",
+  // listing / searching
+  ls: "list_dir", dirlist: "list_dir", listdir: "list_dir",
+  listdirectory: "list_dir", list_directory: "list_dir", listfiles: "list_dir",
+  list_files: "list_dir", list: "list_dir", tree: "list_dir",
+  find: "search_files", findfiles: "search_files", find_files: "search_files",
+  glob: "search_files", grep: "search_content", ripgrep: "search_content",
+  searchtext: "search_content", search_text: "search_content",
+  searchcode: "search_content", search_code: "search_content",
+  contentsearch: "search_content", content_search: "search_content",
+  search: "search_content",
+  // existence
+  exists: "file_exists", stat: "file_exists", checkexists: "file_exists",
+  check_exists: "file_exists", checkfile: "file_exists", check_file: "file_exists",
+  // shell
+  exec: "terminal", execute: "terminal", executecommand: "terminal",
+  execute_command: "terminal", runcommand: "terminal", run_command: "terminal",
+  run: "bash", shell: "bash", cmd: "bash", command: "bash", system: "bash",
+  // code runners
+  runpython: "run_python", python_run: "run_python", py_run: "run_python",
+  execpython: "run_python", exec_python: "run_python", python: "run_python",
+  py: "run_python", runpy: "run_python",
+  runnode: "run_node", node_run: "run_node", js_run: "run_node",
+  runjs: "run_node", nodejs_run: "run_node", node: "run_node", js: "run_node",
+  // package installs
+  install: "install_packages", installpackage: "install_packages",
+  install_package: "install_packages", pip_install: "install_packages",
+  pipinstall: "install_packages", npm_install: "install_packages",
+  npminstall: "install_packages", addpackage: "install_packages",
+  add_package: "install_packages",
+  // http
+  request: "http_request", http: "http_request", fetchapi: "http_request",
+  fetch_api: "http_request", api_request: "http_request", apirequest: "http_request",
+  post: "http_request", getjson: "http_request",
+  // web / todo convenience
+  searchweb: "web_search", search_web: "web_search", websearch: "web_search",
+  fetchurl: "web_fetch", fetch_url: "web_fetch", httpget: "web_fetch",
+  http_get: "web_fetch", curl: "web_fetch",
+  todos: "todo_read", todolist: "todo_read", todo_list: "todo_read",
+};
+
+// Argument key repairs per canonical tool (wrong-key -> right-key).
+const _ARG_GROUPS = {
+  path: ["path", "filepath", "file_path", "filename", "file_name", "name",
+    "file", "target", "location", "folder", "directory", "dir",
+    "dir_path", "dirpath"],
+  content: ["content", "contents", "text", "data", "body", "value",
+    "code", "file_content", "new_text"],
+  old_text: ["old_text", "old_string", "old", "original", "original_text",
+    "search", "find", "old_str"],
+  new_text: ["new_text", "new_string", "replacement", "replace_with", "new_str"],
+  command: ["command", "cmd", "shell", "line", "script", "instruction"],
+};
+
+const FILE_TOOLS = new Set(["read_file", "write_file", "make_dir", "list_dir",
+  "search_files", "search_content", "file_exists"]);
+
+function normTool(name) {
+  return String(name || "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function shortJson(val, limit = 60) {
+  let s;
+  try { s = JSON.stringify(val); } catch { s = String(val); }
+  return s.length > limit ? s.slice(0, limit) + "…" : s;
+}
+
+// Keep model-invented paths inside the current workspace. Small models love
+// writing to /home/<made-up-user>/... which usually does not exist here.
+// Everything else - relative paths, /tmp, the real home - passes through.
+function anchorPath(raw) {
+  if (typeof raw !== "string") return raw;
+  const p = raw.trim();
+  if (!p.startsWith("/home/") && !p.startsWith("/Users/")) return raw;
+  const segs = p.split("/").filter(Boolean);
+  if (segs.length < 3) return raw;
+  const userRoot = "/" + segs.slice(0, 2).join("/");
+  let realHome = false;
+  try {
+    realHome = fs.statSync(userRoot).isDirectory();
+  } catch {}
+  if (realHome) return raw; // a real user home
+  const rest = segs.slice(2);
+  if (!rest.length || rest.includes("..")) return raw;
+  return rest.join("/");
+}
+
+// ---------------------------------------------------------------------------
+// Permissions: file tools never prompt - creating/writing files inside the
+// workspace is the assistant's core job and y/n prompts inside a TUI race
+// with its key reader (mangled answers -> bogus denials). Only genuinely
+// dangerous actions (shell, git history changes, task rewrites) ask.
+class PermissionManager {
+  constructor() {
+    this.auto_approve = false;
+    this.allowed = new Set();
+    this.prompting = false;   // true while a y/n prompt owns the keyboard
+    // UI integration: when set, ask() routes the question here instead of
+    // stdin - callable(toolName, desc) -> "y" | "n" | "a" (async ok).
+    this.ui_hook = null;
+  }
+
+  needs_permission(toolName) {
+    if (this.auto_approve || this.allowed.has(toolName)) return false;
+    return ["terminal", "bash", "git_commit", "todo_write",
+      "run_python", "run_node", "install_packages"].includes(toolName);
+  }
+
+  async ask(toolName, args) {
+    if (!this.needs_permission(toolName)) return true;
+    const desc = args.command || args.path || toolName;
+    this.prompting = true;
+    let r = "";
+    try {
+      if (typeof this.ui_hook === "function") {
+        r = String((await this.ui_hook(toolName, desc)) || "").trim().toLowerCase();
+      } else if (process.stdin.isTTY !== true) {
+        r = "y";          // headless (pipes, CI): no keyboard to ask
+      } else {
+        process.stdout.write(`\n\x1b[33m  Permission:\x1b[0m ${toolName} -> ${String(desc).slice(0, 80)}\n`);
+        r = await askLine("  Allow? (y/n/a=always): ");
+      }
+    } finally {
+      this.prompting = false;
+    }
+    if (["y", "yes", ""].includes(r)) return true;
+    if (["a", "always"].includes(r)) { this.allowed.add(toolName); return true; }
+    return false;
+  }
+}
+
+function askLine(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const rl = require("readline").createInterface({ input: process.stdin, terminal: false });
+    rl.once("line", (line) => { rl.close(); resolve(String(line).trim().toLowerCase()); });
+    rl.once("close", () => resolve(""));
+  });
+}
+
+// ---------------------------------------------------------------------------
+// HTTP with browser-like defaults: search engines reject bot UAs at TLS/HTTP
+// level, and Android/Termux Node builds can ship stale CA stores - so on TLS
+// errors we retry once without verification as a last resort.
+const BROWSER_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0",
+  "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9",
+};
+
+function httpGet(url, opts = {}, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    const mod = url.startsWith("https") ? https : http;
+    const req = mod.get(url, {
+      headers: { ...BROWSER_HEADERS, ...(opts.headers || {}) },
+      timeout: opts.timeout || 15000,
+      rejectUnauthorized: !opts.insecure,
+    }, (res) => {
+      if ([301, 302, 303, 307, 308].includes(res.statusCode || 0)
+          && res.headers.location && redirects < 4) {
+        res.resume();
+        httpGet(new URL(res.headers.location, url).toString(), opts, redirects + 1)
+          .then(resolve, reject);
+        return;
+      }
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve({
+        status: res.statusCode || 0,
+        text: Buffer.concat(chunks).toString("utf8"),
+        headers: res.headers,
+      }));
+    });
+    req.on("timeout", () => req.destroy(new Error("Timeout")));
+    req.on("error", (e) => {
+      if (!opts.insecure && /certificate|CERT|TLS|ssl/i.test(`${e.code || ""} ${e.message}`)) {
+        httpGet(url, { ...opts, insecure: true }, redirects).then(resolve, reject);
+      } else reject(e);
+    });
+  });
+}
+
+function stripTags(s) {
+  return s.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function parseGoogle(html, n) {
+  const out = [], seen = new Set();
+  const rx = /<a[^>]+href="(?:(?:\/url\?q=)|(?:https?:\/\/[^\/]*google\.[^\/]*\/url\?q=))?([^"&]+)[^"]*"[^>]*>([\s\S]*?)<\/a>/g;
+  let m;
+  while ((m = rx.exec(html)) && out.length < n) {
+    let url = m[1];
+    try { url = decodeURIComponent(url); } catch {}
+    const title = stripTags(m[2]);
+    if (!title || !/^https?:\/\/|^\/url\?q=/.test(m[1]) || /^https?:$/.test(url)) continue;
+    if (!/^https?:\/\//.test(url)) continue;
+    if (/google\.|gstatic\.|googleads|doubleclick/i.test(url)) continue;
+    if (seen.has(url)) continue;
+    seen.add(url);
+    out.push(`  ${title}\n    ${url}`);
+  }
+  if (!out.length) {
+    for (const mm of html.matchAll(/href="(https?:\/\/[^"]+)"/g)) {
+      const u = mm[1];
+      if (/google\.|gstatic\./i.test(u) || seen.has(u)) continue;
+      seen.add(u);
+      out.push(`  ${u}`);
+      if (out.length >= n) break;
+    }
+  }
+  return out;
+}
+
+function parseDdg(html, n) {
+  const out = [], seen = new Set();
+  const rx = /<a[^>]+class="result__a"[^>]*>/g;
+  let m;
+  while ((m = rx.exec(html)) && out.length < n) {
+    const tail = html.slice(m.index, m.index + 500);
+    const href = (tail.match(/href="([^"]+)"/) || [])[1] || "";
+    const titleM = tail.match(/>([\s\S]*?)<\/a>/);
+    let url = href.startsWith("//") ? "https:" + href : href;
+    const title = titleM ? stripTags(titleM[1]) : "";
+    if (!title || !/^https?:\/\//.test(url) || /duckduckgo\.com/.test(url)) continue;
+    if (seen.has(url)) continue;
+    seen.add(url);
+    out.push(`  ${title}\n    ${url}`);
+  }
+  if (!out.length) {  // fallback: any external link
+    for (const mm of html.matchAll(/href="(https?:\/\/[^"]+)"/g)) {
+      const u = mm[1];
+      if (/duckduckgo\.com/.test(u) || seen.has(u)) continue;
+      seen.add(u);
+      out.push(`  ${u}`);
+      if (out.length >= n) break;
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Tool implementations
+
+function safeDecode(s) {
+  try { return decodeURIComponent(s); } catch { return s; }
+}
+
+function b64uDecode(s) {
+  try {
+    return Buffer.from(s, "base64url").toString("utf8");
+  } catch {
+    return "";
+  }
+}
+
+// Markdown pages from the r.jina.ai renderer: [title](url) where url is
+// either a DDG redirect (?uddg=<enc>) or a Bing redirect (&u=a1<b64>).
+function parseMdLinks(text, n) {
+  const out = [], seen = new Set();
+  for (const m of text.matchAll(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g)) {
+    let url = m[2];
+    const mu = url.match(/[?&]uddg=([^&\s)]+)/);
+    if (mu) {
+      url = safeDecode(mu[1]);
+    } else {
+      const mb = url.match(/[?&]u=a1([A-Za-z0-9_\-%]+)/);
+      if (!mb) continue;
+      url = b64uDecode(mb[1]);
+    }
+    const title = m[1].replace(/\s+/g, " ").trim()
+      .replace(/^\*+|\*+$/g, "").replace(/^`|`$/g, "");
+    if (!title || !/^https?:\/\//.test(url) || seen.has(url)) continue;
+    if (/duckduckgo\.com|bing\.com\/ck\/|\.bing\.com\/search|google\.|external-content/.test(url)) continue;
+    seen.add(url);
+    out.push(`  ${title}\n    ${url}`);
+    if (out.length >= n) break;
+  }
+  return out;
+}
+
+// Bing wraps result links in /ck/a?...&u=a1<base64url-of-real-url>.
+function parseBing(html, n) {
+  const out = [], seen = new Set();
+  for (const m of html.matchAll(/<a[^>]+href="([^"]*ck\/a\?[^"]*)"[^>]*>([\s\S]*?)<\/a>/g)) {
+    const href = m[1].replace(/&amp;/g, "&");
+    const mb = href.match(/[?&]u=a1([A-Za-z0-9_\-]+)/);
+    if (!mb) continue;
+    const url = b64uDecode(mb[1]);
+    const title = stripTags(m[2]);
+    if (!title || !/^https?:\/\//.test(url) || /bing\.com/.test(url) || seen.has(url)) continue;
+    seen.add(url);
+    out.push(`  ${title}\n    ${url}`);
+    if (out.length >= n) break;
+  }
+  return out;
+}
+
+function parseGoogleApi(body, n) {
+  try {
+    const items = JSON.parse(body).items || [];
+    return items.slice(0, n)
+      .filter((it) => it.link)
+      .map((it) => `  ${it.title || ""}\n    ${it.link}`);
+  } catch {
+    return [];
+  }
+}
+
+async function runShell(command, cwd = ".", timeout = 30000) {
+  const r = spawnSync("bash", ["-c", command], {
+    cwd: path.resolve(cwd), timeout,
+    encoding: "utf-8", maxBuffer: 16 * 1024 * 1024,
+  });
+  if (r.error && r.error.code === "ETIMEDOUT") {
+    return new ToolResult("", `Timeout after ${timeout}s`, false);
+  }
+  if (r.error) return new ToolResult("", r.error.message, false);
+  let out = r.stdout || "";
+  if (r.stderr) out += `\n[stderr]\n${r.stderr}`;
+  if (r.status !== 0) out += `\n[exit ${r.status}]`;
+  return new ToolResult(out.slice(0, 50000) || "Done (no output)");
+}
+
+// Run code with an interpreter directly (argv, never a shell) so user code
+// can't be mangled by quoting and packages install safely.
+function runInterpreter(bin, argv, cwd, timeout) {
+  const r = spawnSync(bin, argv, {
+    cwd: path.resolve(cwd || "."), timeout: timeout || 30000,
+    encoding: "utf-8", maxBuffer: 16 * 1024 * 1024,
+    env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1" },
+  });
+  if (r.error && r.error.code === "ETIMEDOUT") {
+    return new ToolResult("", `Timeout after ${timeout || 30}s`, false);
+  }
+  if (r.error && r.error.code === "ENOENT") {
+    return new ToolResult("", `${bin} is not installed on this device`, false);
+  }
+  if (r.error) return new ToolResult("", r.error.message, false);
+  let out = r.stdout || "";
+  if (r.stderr) out += `\n[stderr]\n${r.stderr}`;
+  if (r.status !== 0) out += `\n[exit ${r.status}]`;
+  return new ToolResult(out.trim().slice(0, 20000) || "Done (no output)");
+}
+
+function httpRequest(url, { method = "GET", headers = {}, body = null, timeout = 20000 } = {}) {
+  return new Promise((resolve, reject) => {
+    let u;
+    try { u = new URL(url); } catch { return reject(new Error(`Invalid URL: ${url}`)); }
+    const mod = u.protocol === "http:" ? require("http") : require("https");
+    const req = mod.request(u, {
+      method, headers: { "User-Agent": BROWSER_HEADERS["User-Agent"], ...headers },
+      timeout,
+    }, (res) => {
+      let data = "";
+      res.setEncoding("utf-8");
+      res.on("data", (c) => { data += c; if (data.length > 2e6) req.destroy(); });
+      res.on("end", () => resolve({ status: res.statusCode, text: data }));
+    });
+    req.on("timeout", () => { req.destroy(new Error(`Timeout after ${timeout / 1000}s`)); });
+    req.on("error", reject);
+    if (body != null) req.write(body);
+    req.end();
+  });
+}
+
+const TOOLS = [
+  new ToolDef("read_file", "Read file contents with line numbers", {
+    type: "object",
+    properties: {
+      path: { type: "string" },
+      start_line: { type: "integer" },
+      end_line: { type: "integer" },
+    },
+    required: ["path"],
+  }),
+  new ToolDef("write_file",
+    "Create or overwrite a file (parent folders are created automatically)", {
+      type: "object",
+      properties: { path: { type: "string" }, content: { type: "string" } },
+      required: ["path", "content"],
+    }, true),
+  new ToolDef("make_dir",
+    "Create a folder/directory (nested parents are created automatically)", {
+      type: "object", properties: { path: { type: "string" } }, required: ["path"],
+    }),
+  new ToolDef("edit_file", "Replace exact text in file", {
+    type: "object",
+    properties: {
+      path: { type: "string" }, old_text: { type: "string" }, new_text: { type: "string" },
+    },
+    required: ["path", "old_text", "new_text"],
+  }, true),
+  new ToolDef("list_dir", "List directory contents", {
+    type: "object",
+    properties: { path: { type: "string" }, pattern: { type: "string" } },
+  }),
+  new ToolDef("search_files", "Find files by glob pattern", {
+    type: "object",
+    properties: { pattern: { type: "string" }, path: { type: "string" } },
+    required: ["pattern"],
+  }),
+  new ToolDef("search_content", "Search text inside files", {
+    type: "object",
+    properties: {
+      query: { type: "string" }, path: { type: "string" }, include: { type: "string" },
+    },
+    required: ["query"],
+  }),
+  new ToolDef("file_exists", "Check if file/dir exists", {
+    type: "object", properties: { path: { type: "string" } }, required: ["path"],
+  }),
+  new ToolDef("terminal", "Execute a shell command", {
+    type: "object",
+    properties: {
+      command: { type: "string" }, cwd: { type: "string" }, timeout: { type: "integer" },
+    },
+    required: ["command"],
+  }, true),
+  new ToolDef("bash", "Run a shell command", {
+    type: "object",
+    properties: {
+      command: { type: "string" }, cwd: { type: "string" }, timeout: { type: "integer" },
+    },
+    required: ["command"],
+  }, true),
+  new ToolDef("run_python",
+    "Execute Python 3 code (or a .py file) and see its output - use this to TEST scripts you wrote", {
+      type: "object",
+      properties: {
+        code: { type: "string" }, path: { type: "string" },
+        cwd: { type: "string" }, timeout: { type: "integer" },
+      },
+    }, true),
+  new ToolDef("run_node",
+    "Execute JavaScript with Node.js (or a .js file) and see its output - use this to TEST scripts you wrote", {
+      type: "object",
+      properties: {
+        code: { type: "string" }, path: { type: "string" },
+        cwd: { type: "string" }, timeout: { type: "integer" },
+      },
+    }, true),
+  new ToolDef("install_packages",
+    "Install packages with pip or npm, e.g. manager='pip', packages=['flask']", {
+      type: "object",
+      properties: {
+        manager: { type: "string", enum: ["pip", "pip3", "npm"] },
+        packages: { type: "array", items: { type: "string" } },
+        timeout: { type: "integer" },
+      },
+      required: ["packages"],
+    }, true),
+  new ToolDef("http_request",
+    "Call any HTTP API and get the response body (GET/POST/PUT/DELETE with headers and body)", {
+      type: "object",
+      properties: {
+        url: { type: "string" }, method: { type: "string" },
+        headers: { type: "object" }, body: { type: "string" },
+        timeout: { type: "integer" },
+      },
+      required: ["url"],
+    }),
+  new ToolDef("git_status", "Show working tree status", {
+    type: "object", properties: {}, required: [],
+  }),
+  new ToolDef("git_diff", "Show uncommitted changes", {
+    type: "object", properties: {}, required: [],
+  }),
+  new ToolDef("git_log", "Show recent commit history", {
+    type: "object",
+    properties: { count: { type: "integer", description: "How many commits (default 10)" } },
+    required: [],
+  }),
+  new ToolDef("git_commit", "Stage everything and commit", {
+    type: "object",
+    properties: { message: { type: "string", description: "Commit message" } },
+    required: ["message"],
+  }, true),
+  new ToolDef("git_branch", "List branches or show the current one", {
+    type: "object", properties: {}, required: [],
+  }),
+  new ToolDef("web_search", "Search the web (Google)", {
+    type: "object",
+    properties: {
+      query: { type: "string" },
+      num_results: { type: "integer", description: "How many results (default 5)" },
+    },
+    required: ["query"],
+  }),
+  new ToolDef("web_fetch", "Fetch URL content", {
+    type: "object",
+    properties: {
+      url: { type: "string" },
+      max_chars: { type: "integer", description: "Max characters to return (default 5000)" },
+    },
+    required: ["url"],
+  }),
+  new ToolDef("todo_read", "Read todo list", {
+    type: "object", properties: {}, required: [],
+  }),
+  new ToolDef("todo_write", "Write todo list", {
+    type: "object",
+    properties: {
+      todos: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { text: { type: "string" }, done: { type: "boolean" } },
+        },
+      },
+    },
+    required: ["todos"],
+  }, true),
+  new ToolDef("ogpt_command",
+    "Run an internal OGPT command. Available: /help, /status, /models, /catalog, " +
+      "/model <oGPT-name|id> (switch model), /memory add <text>, /task new <desc>, " +
+      "/index, /skills, /history, /ps, /warmup, /save. Use when the user asks to switch " +
+      "models, save sessions, store notes, or inspect OGPT itself.",
+    {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "Full command line including leading slash, e.g. '/model oGPT-2a' or '/memory add prefers Python'",
+        },
+      },
+      required: ["command"],
+    }),
+];
+
+function todoFile() {
+  return path.join(os.homedir(), ".config", "ogpt", "todos.json");
+}
+
+function globToRx(pattern) {
+  const esc = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*/g, "\u0000").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${esc}$`, "i");
+}
+
+const IMPLEMENTATIONS = {
+  read_file(args) {
+    const p = path.resolve(anchorPath(String(args.path)).replace(/^~(?=$|\/)/, os.homedir()));
+    if (!fs.existsSync(p)) return new ToolResult("", `Not found: ${p}`, false);
+    const lines = fs.readFileSync(p, "utf-8").split("\n");
+    const s = Math.max(0, parseInt(args.start_line || 1, 10) - 1);
+    const e = Math.min(lines.length, parseInt(args.end_line || lines.length, 10));
+    const numbered = lines.slice(s, e)
+      .map((l, i) => `${String(i + s + 1).padStart(4)}: ${l}`).join("\n");
+    return new ToolResult(`File: ${p} (${lines.length} lines)\n${numbered}`);
+  },
+
+  write_file(args) {
+    const raw = String(args.path || "").trim();
+    if (!raw) return new ToolResult("", "Empty path", false);
+    const p = path.resolve(raw.replace(/^~(?=$|\/)/, os.homedir()));
+    const existed = fs.existsSync(p);
+    let content = String(args.content ?? "");
+    if (!content.trim()) {
+      // An empty .html file gets a professional HTML5 skeleton (page title
+      // from the file name) instead of a blank 0-byte file.
+      if (path.extname(p).toLowerCase() === ".html") {
+        let title = path.basename(p, ".html").replace(/[-_]/g, " ").trim();
+        title = title ? title[0].toUpperCase() + title.slice(1) : "Document";
+        content =
+          "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n" +
+          "  <meta charset=\"UTF-8\">\n" +
+          "  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n" +
+          `  <title>${title}</title>\n` +
+          "</head>\n<body>\n\n</body>\n</html>\n";
+      }
+    }
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, content, "utf-8");
+    const nLines = content.split("\n").length - (content.endsWith("\n") ? 1 : 0) || (content ? 1 : 0);
+    return new ToolResult(
+      `${existed ? "Updated" : "Created"} ${p} (${nLines} lines, ${hsz(Buffer.byteLength(content))})`);
+  },
+
+  make_dir(args) {
+    const raw = String(args.path || "").trim();
+    if (!raw) return new ToolResult("", "Empty path", false);
+    const p = path.resolve(raw.replace(/^~(?=$|\/)/, os.homedir()));
+    if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+      return new ToolResult(`Directory already exists: ${p}`);
+    }
+    if (fs.existsSync(p)) {
+      return new ToolResult("", `'${p}' already exists as a FILE. Do not make_dir files - ` +
+        `call write_file directly instead (parent folders are created automatically). ` +
+        `Example: ${JSON.stringify({ name: "write_file", arguments: { path: raw, content: "...your code..." } })}`,
+        false);
+    }
+    fs.mkdirSync(p, { recursive: true });
+    return new ToolResult(`Created directory: ${p}`);
+  },
+
+  edit_file(args) {
+    const p = path.resolve(anchorPath(String(args.path)).replace(/^~(?=$|\/)/, os.homedir()));
+    if (!fs.existsSync(p)) return new ToolResult("", `Not found: ${p}`, false);
+    const content = fs.readFileSync(p, "utf-8");
+    const oldT = String(args.old_text ?? ""), newT = String(args.new_text ?? "");
+    if (!content.includes(oldT)) return new ToolResult("", `Text not found in ${path.basename(p)}`, false);
+    const count = content.split(oldT).length - 1;
+    fs.writeFileSync(p, content.replace(oldT, newT), "utf-8");
+    return new ToolResult(`Replaced 1 of ${count} in ${path.basename(p)}` +
+      (count > 1 ? ` (${count - 1} more)` : ""));
+  },
+
+  list_dir(args) {
+    const p = path.resolve(anchorPath(String(args.path || ".")).replace(/^~(?=$|\/)/, os.homedir()));
+    if (!fs.existsSync(p) || !fs.statSync(p).isDirectory()) {
+      return new ToolResult("", `Not dir: ${p}`, false);
+    }
+    let entries = fs.readdirSync(p, { withFileTypes: true })
+      .filter((e) => !IGNORE.has(e.name))
+      .sort((a, b) => (b.isDirectory() - a.isDirectory())
+        || a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    if (args.pattern) {
+      const rx = globToRx(String(args.pattern));
+      entries = entries.filter((e) => rx.test(e.name));
+    }
+    const lines = entries.slice(0, 80).map((e) => {
+      if (e.isDirectory()) return `  ${e.name}/`;
+      const st = fs.statSync(path.join(p, e.name));
+      return `  ${e.name} (${hsz(st.size)})`;
+    });
+    return new ToolResult(`Contents of ${p}:\n${lines.join("\n")}`);
+  },
+
+  search_files(args) {
+    const root = path.resolve(anchorPath(String(args.path || ".")));
+    const rx = globToRx(String(args.pattern));
+    const results = [];
+    const walk = (d) => {
+      if (results.length >= 200) return;
+      let items;
+      try { items = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+      for (const e of items) {
+        if (results.length >= 200) return;
+        const full = path.join(d, e.name);
+        if (e.isDirectory()) {
+          if (!IGNORE.has(e.name)) walk(full);
+        } else if (rx.test(e.name)) {
+          results.push(path.relative(root, full));
+        }
+      }
+    };
+    walk(root);
+    return results.length
+      ? new ToolResult(`Found ${results.length}:\n${results.slice(0, 100).join("\n")}`)
+      : new ToolResult(`No matches for '${args.pattern}'`);
+  },
+
+  search_content(args) {
+    const q = String(args.query || "").toLowerCase();
+    const root = path.resolve(anchorPath(String(args.path || ".")).replace(/^~(?=$|\/)/, os.homedir()));
+    const inc = args.include ? globToRx(String(args.include)) : null;
+    const results = [];
+    const walk = (d) => {
+      let items;
+      try { items = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+      for (const e of items) {
+        if (results.length >= 50) return;
+        const full = path.join(d, e.name);
+        if (e.isDirectory()) {
+          if (!IGNORE.has(e.name)) walk(full);
+          continue;
+        }
+        if (inc && !inc.test(e.name)) continue;
+        let st;
+        try { st = fs.statSync(full); } catch { continue; }
+        if (st.size > 2 * 1024 * 1024) continue;
+        try {
+          const lines = fs.readFileSync(full, "utf-8").split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].toLowerCase().includes(q)) {
+              results.push(`${path.relative(root, full)}:${i + 1}: ${lines[i].trimEnd().slice(0, 120)}`);
+              if (results.length >= 50) return;
+            }
+          }
+        } catch {}
+      }
+    };
+    walk(root);
+    return results.length
+      ? new ToolResult(`Matches:\n${results.join("\n")}`)
+      : new ToolResult(`No matches for '${args.query}'`);
+  },
+
+  file_exists(args) {
+    const p = path.resolve(anchorPath(String(args.path)).replace(/^~(?=$|\/)/, os.homedir()));
+    if (fs.existsSync(p)) {
+      const t = fs.statSync(p).isDirectory() ? "dir" : "file";
+      return new ToolResult(`Exists (${t}): ${p}`);
+    }
+    return new ToolResult(`Not found: ${p}`);
+  },
+
+  terminal(args) {
+    return runShell(String(args.command || ""), args.cwd || ".",
+      parseInt(args.timeout || 30, 10) * 1000);
+  },
+
+  bash(args) {
+    return runShell(String(args.command || ""), args.cwd || ".",
+      parseInt(args.timeout || 30, 10) * 1000);
+  },
+
+  run_python(args) {
+    const code = args.code != null ? String(args.code) : "";
+    const file = String(args.path || "").trim();
+    if (!code.trim() && !file) {
+      return new ToolResult("", "Provide 'code' (Python source to run) or 'path' (a .py file)", false);
+    }
+    const argv = file ? [file] : ["-c", code];
+    return runInterpreter("python3", argv, args.cwd || ".", parseInt(args.timeout || 60, 10) * 1000);
+  },
+
+  run_node(args) {
+    const code = args.code != null ? String(args.code) : "";
+    const file = String(args.path || "").trim();
+    if (!code.trim() && !file) {
+      return new ToolResult("", "Provide 'code' (JavaScript source to run) or 'path' (a .js file)", false);
+    }
+    const argv = file ? [file] : ["-e", code];
+    return runInterpreter("node", argv, args.cwd || ".", parseInt(args.timeout || 60, 10) * 1000);
+  },
+
+  install_packages(args) {
+    let pkgs = args.packages;
+    if (typeof pkgs === "string") pkgs = pkgs.split(/\s+/);
+    if (!Array.isArray(pkgs) || !pkgs.length || !pkgs.every((p) => /^[\w@/.+-]+$/.test(p))) {
+      return new ToolResult("", "'packages' must be a list of package names, e.g. "
+        + `{"name": "install_packages", "arguments": {"manager": "pip", "packages": ["flask"]}}`, false);
+    }
+    let mgr = String(args.manager || "pip").trim().toLowerCase();
+    if (mgr === "python" || mgr === "py") mgr = "pip";
+    if (mgr === "node" || mgr === "nodejs" || mgr === "javascript") mgr = "npm";
+    if (!["pip", "pip3", "npm"].includes(mgr)) {
+      return new ToolResult("", `'manager' must be one of pip, pip3 or npm - got '${mgr}'`, false);
+    }
+    if (mgr.startsWith("pip")) {
+      return runInterpreter(mgr, ["install", ...pkgs], ".",
+        parseInt(args.timeout || 300, 10) * 1000);
+    }
+    // npm: install into the workspace, not global
+    return runInterpreter("npm", ["install", ...pkgs], ".",
+      parseInt(args.timeout || 300, 10) * 1000);
+  },
+
+  async http_request(args) {
+    const url = String(args.url || "").trim();
+    if (!/^https?:\/\//i.test(url)) {
+      return new ToolResult("", "'url' must start with http:// or https://", false);
+    }
+    try {
+      const res = await httpRequest(url, {
+        method: String(args.method || "GET").toUpperCase(),
+        headers: args.headers && typeof args.headers === "object" ? args.headers : {},
+        body: args.body != null ? String(args.body) : null,
+        timeout: parseInt(args.timeout || 20, 10) * 1000,
+      });
+      return new ToolResult(`HTTP ${res.status} ${url}\n${res.text.slice(0, 8000)}`);
+    } catch (e) {
+      return new ToolResult("", e.message, false);
+    }
+  },
+
+  git_status() { return runShell("git status --short --branch"); },
+  git_diff() { return runShell("git diff HEAD"); },
+  git_log(args) { return runShell(`git log --oneline -n ${parseInt(args.count || 10, 10)}`); },
+  async git_commit(args) {
+    const msg = String(args.message || "").trim();
+    if (!msg) return new ToolResult("", "Missing required argument 'message' for git_commit. "
+      + `Send it with real values, e.g. ${JSON.stringify({ name: "git_commit", arguments: { message: "Fix login bug" } })}`, false);
+    await runShell('git add -A');
+    return runShell(`git commit -m ${JSON.stringify(msg)}`);
+  },
+  git_branch() { return runShell("git branch --show-current && git branch"); },
+
+  async web_search(args) {
+    const query = String(args.query || "");
+    const n = Math.max(1, parseInt(args.num_results || 5, 10));
+    const q = encodeURIComponent(query);
+    // Official Google Programmable Search when the user configured keys -
+    // the cleanest way to talk to Google.
+    let apiKey = "", cx = "";
+    try {
+      const { getConfig } = require("./config");
+      const cfg = getConfig();
+      apiKey = cfg.get("web.google_api_key", "") || "";
+      cx = cfg.get("web.google_cx", "") || "";
+    } catch {}
+    const endpoints = [];
+    if (apiKey && cx) {
+      endpoints.push({
+        url: `https://www.googleapis.com/customsearch/v1?key=${apiKey}&cx=${cx}&num=${Math.min(n, 10)}&q=${q}`,
+        parse: parseGoogleApi,
+      });
+    }
+    endpoints.push(
+      { url: `https://www.bing.com/search?q=${q}&count=10`, parse: parseBing },
+      { url: `https://html.duckduckgo.com/html/?q=${q}`, parse: parseDdg },
+      { url: `https://lite.duckduckgo.com/lite/?q=${q}`, parse: parseDdg },
+      // Server-rendered proxies rescue locked-down networks where carriers
+      // reset engine domains or Google demands JavaScript.
+      { url: `https://r.jina.ai/https://html.duckduckgo.com/html/?q=${q}`, parse: parseMdLinks },
+      { url: `https://r.jina.ai/https://www.bing.com/search?q=${q}`, parse: parseMdLinks },
+      {
+        url: `https://www.google.com/search?q=${q}&gbv=1&num=10`,
+        headers: { Cookie: "CONSENT=YES+cb.20240101-01-p0.en+FX+000" },
+        parse: parseGoogle,
+      },
+    );
+    let lastErr = "";
+    for (const ep of endpoints) {
+      try {
+        const res = await httpGet(ep.url, { headers: ep.headers });
+        if (res.status !== 200) { lastErr = `${ep.url} -> HTTP ${res.status}`; continue; }
+        const results = ep.parse(res.text, n);
+        if (results.length) {
+          return new ToolResult(`Results for '${query}':\n${results.join("\n")}`);
+        }
+        lastErr = `${ep.url} returned no parseable results`;
+      } catch (e) {
+        lastErr = `${ep.url} -> ${e.message}`;
+      }
+    }
+    return new ToolResult("",
+      `No search backend responded (${lastErr}). Try web_fetch on a known URL.`, false);
+  },
+
+  async web_fetch(args) {
+    const url = String(args.url || "");
+    const maxChars = parseInt(args.max_chars || 5000, 10);
+    const clean = (res) => {
+      let text = res.text.slice(0, 30000);
+      if (/html/i.test(res.headers["content-type"] || "") || /<html/i.test(text)) {
+        text = text.replace(/<script[\s\S]*?<\/script>/gi, " ")
+          .replace(/<style[\s\S]*?<\/style>/gi, " ")
+          .replace(/<[^>]+>/g, " ")
+          .replace(/\s+/g, " ").trim();
+      }
+      return text;
+    };
+    try {
+      const res = await httpGet(url, {});
+      if (res.status >= 400) throw new Error(`HTTP ${res.status} for ${url}`);
+      const text = clean(res);
+      if (!text.trim()) throw new Error("empty page (JS-only site?)");
+      return new ToolResult(`URL: ${url}\n${text.slice(0, maxChars)}`);
+    } catch (e) {
+      // Locked-down networks / JS-only sites: try the server-side renderer
+      // before giving up.
+      try {
+        const res = await httpGet(`https://r.jina.ai/${url}`, { timeout: 30000 });
+        if (res.status === 200 && res.text.trim()) {
+          return new ToolResult(`URL: ${url}\n${res.text.slice(0, maxChars)}`);
+        }
+      } catch {}
+      return new ToolResult("", e.message, false);
+    }
+  },
+
+  todo_read() {
+    try {
+      const data = JSON.parse(fs.readFileSync(todoFile(), "utf-8"));
+      const items = Array.isArray(data) ? data : data.todos || [];
+      if (!items.length) return new ToolResult("No todos.");
+      return new ToolResult(items.map((t, i) =>
+        `  ${i + 1}. [${t.done ? "x" : " "}] ${t.text}`).join("\n"));
+    } catch {
+      return new ToolResult("No todos.");
+    }
+  },
+
+  todo_write(args) {
+    const todos = Array.isArray(args.todos) ? args.todos : null;
+    if (!todos) return new ToolResult("", "'todos' must be an array of {text, done}", false);
+    fs.mkdirSync(path.dirname(todoFile()), { recursive: true });
+    fs.writeFileSync(todoFile(), JSON.stringify(todos.map((t) => ({
+      text: String(t.text || ""), done: !!t.done,
+    })), null, 2));
+    return new ToolResult(`Saved ${todos.length} todos`);
+  },
+};
+
+class ToolRegistry {
+  constructor() {
+    this._tools = {};
+    this._perm = new PermissionManager();
+    this._log = [];
+    // Set by the CLI: (commandLine) => output string
+    this.commandDispatcher = null;
+    for (const t of TOOLS) this._tools[t.name] = t;
+  }
+
+  // Backwards-compat for older callers that read registry._autoApprove.
+  get _autoApprove() { return this._perm.auto_approve; }
+
+  definitions() {
+    return Object.values(this._tools).map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+    }));
+  }
+
+  listTools() { return Object.values(this._tools); }
+
+  names() { return Object.keys(this._tools); }
+
+  canonicalName(name) { return this.resolveName(name); }
+
+  resolveName(name) {
+    if (Object.prototype.hasOwnProperty.call(this._tools, name)) return name;
+    const n = normTool(name);
+    if (!n) return name;
+    const canon = TOOL_ALIASES[n];
+    if (canon && this._tools[canon]) return canon;
+    for (const known of Object.keys(this._tools)) {
+      if (normTool(known) === n) return known;
+    }
+    // last resort: unique suffix match ("write" -> "write_file")
+    const hits = Object.keys(this._tools)
+      .filter((k) => normTool(k).endsWith(n) || n.endsWith(normTool(k)));
+    if (hits.length === 1) return hits[0];
+    return name;
+  }
+
+  prepareCall(toolCall) {
+    // Canonicalize name AND argument keys on a tool call (in place) so chips,
+    // snapshots and code events all work with the canonical view.
+    try {
+      const resolved = this.resolveName(toolCall.name);
+      if (resolved !== toolCall.name) toolCall.name = resolved;
+      const tool = this._tools[resolved];
+      if (tool) {
+        toolCall.arguments = this.repairArgs(tool, toolCall.arguments || {});
+      }
+    } catch {}
+    return toolCall;
+  }
+
+  repairArgs(tool, args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) return {};
+    const props = (tool.parameters && tool.parameters.properties) || {};
+    const fixed = { ...args };
+    // already-valid keys stay untouched
+    for (const [canonical, aliases] of Object.entries(_ARG_GROUPS)) {
+      if (props[canonical] && !(canonical in fixed)) {
+        for (const alias of aliases) {
+          if (alias !== canonical && alias in args) { fixed[canonical] = args[alias]; break; }
+        }
+      }
+    }
+    if (FILE_TOOLS.has(tool.name) && typeof fixed.path === "string") {
+      fixed.path = anchorPath(fixed.path);
+    }
+    return fixed;
+  }
+
+  validateArgs(tool, args) {
+    // Return a teaching error when args are malformed (schema parroting,
+    // wrong types, missing required keys).
+    const params = tool.parameters || {};
+    const props = params.properties || {};
+    for (const [key, spec] of Object.entries(props)) {
+      if (!(key in args)) continue;
+      const val = args[key];
+      const vtype = spec && spec.type;
+      if (vtype === "string" && val != null && typeof val !== "string"
+          && typeof val !== "number" && typeof val !== "boolean") {
+        const example = JSON.stringify({ name: tool.name, arguments: { [key]: "my_folder" } });
+        return `Invalid arguments for ${tool.name}: '${key}' must be a plain string, `
+          + `but you sent ${shortJson(val)}. Do not copy the parameter schema - `
+          + `use real values. Correct shape: ${example}`;
+      }
+    }
+    for (const key of params.required || []) {
+      const v = args[key];
+      // 'content'/'text' may legitimately be an empty string - write_file
+      // fills in a starter template for known types (e.g. HTML boilerplate).
+      const allowEmpty = key === "content" || key === "text" || key === "todos";
+      if (!(key in args) || v == null ||
+          (!allowEmpty && (v === "" ||
+            (Array.isArray(v) && !v.length) ||
+            (typeof v === "object" && !Array.isArray(v) && !Object.keys(v).length)))) {
+        return `Missing required argument '${key}' for ${tool.name}. `
+          + `Send it with real values, e.g. `
+          + `${JSON.stringify({ name: tool.name, arguments: { [key]: "value" } })}`;
+      }
+    }
+    return null;
+  }
+
+  async execute(toolCall) {
+    const id = toolCall.id || "";
+    const requested = toolCall.name;
+    const resolved = this.resolveName(requested);
+    const tool = this._tools[resolved];
+    if (!tool) {
+      return new ToolResult("",
+        `Unknown tool '${requested}'. You must call exactly one of these tools: `
+        + `${this.names().sort().join(", ")}.`, false);
+    }
+    const args = this.repairArgs(tool, toolCall.arguments || {});
+    const problem = this.validateArgs(tool, args);
+    if (problem) return this._finish(id, resolved, problem, false);
+
+    if (!(await this._perm.ask(tool.name, args))) {
+      return this._finish(id, resolved, "Permission denied", false);
+    }
+
+    let result;
+    try {
+      result = await IMPLEMENTATIONS[resolved](args);
+    } catch (e) {
+      result = new ToolResult("", e.message, false);
+    }
+    this._log.push({ tool: resolved, success: result.success });
+    return this._finish(id, resolved, result.content, result.success, result);
+  }
+
+  _finish(id, name, content, success, base) {
+    const r = base || new ToolResult();
+    r.toolCallId = id;
+    r.name = name;
+    if (success) r.output = content;
+    else r.error = content.replace(/^Error: /, "");
+    r.success = success;
+    return r;
+  }
+
+  toggleApprove(toolName) {
+    if (toolName) {
+      this._perm.allowed.add(toolName);
+      return `Auto-approved: ${toolName}`;
+    }
+    this._perm.auto_approve = !this._perm.auto_approve;
+    return `Auto-approve all: ${this._perm.auto_approve ? "ON" : "OFF"}`;
+  }
+}
+
+module.exports = { ToolRegistry, ToolDef, ToolResult, TOOLS };