@krmxd/onegpt 0.1.8-fix-beta → 0.2.0-beta

package/bin/ogpt.js

@@ -133,6 +133,23 @@ Options:
 
   if (noStream) cfg.set("ui.stream", false);
 
+  // Local-engine bootstrap: install/start the engine and make sure a model
+  // exists BEFORE chatting, so users never see raw ECONNREFUSED errors.
+  if ((cfg.get("active_provider", "ollama") || "ollama") === "ollama"
+      && args[0] !== "--help") {
+    const { ensureLocalEngine } = require("../src/ollama-setup");
+    const res = await ensureLocalEngine({
+      host: cfg.get("providers.ollama.host"),
+      model: cfg.activeModel ? cfg.activeModel() : cfg.get("active_model"),
+    });
+    if (res.ok && res.model && res.model !== cfg.get("active_model")) {
+      cfg.set("active_model", res.model);
+    }
+    if (!res.ok && res.reason) {
+      console.log("\n" + res.reason + "\n");
+    }
+  }
+
   const cli = new CLI({ config: cfg });
 
   if (autoApprove) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krmxd/onegpt",
-  "version": "0.1.8-fix-beta",
+  "version": "0.2.0-beta",
   "description": "OGPT - AI coding assistant for the terminal with a built-in local engine",
   "main": "src/index.js",
   "bin": {

package/src/agent.js

@@ -85,6 +85,9 @@ const TOOL_GUIDANCE = (
   "boilerplate, never code dumped only in chat.\n" +
   "- write_file creates a file AND all missing parent folders automatically, so a separate " +
   "make_dir call is usually unnecessary - just call write_file with the full path.\n" +
+  "- You also have move_path, copy_path and delete_path to reorganize files, and " +
+  "web_search (Google) + web_fetch for live documentation - prefer checking real docs " +
+  "over guessing APIs.\n" +
   "- Complete EVERY part of the request before replying. If asked for a folder and files " +
   "inside it, make all the tool calls in one turn: one write_file per file.\n" +
   "- Never stop halfway: after each tool result, continue with the next step until the " +
@@ -214,11 +217,16 @@ The user asked you to build a web project. Deliver a COMPLETE working site:
 1. PLAN first - list every file you will create (2-4 lines max).
 2. Create ALL of these in a project folder: index.html, styles.css, script.js.
 3. Quality bar (mandatory):
-   - index.html: semantic HTML5 with viewport meta, linking styles.css and script.js
-   - styles.css: modern design - custom properties, flexbox/grid layout, responsive media queries, hover/focus states (aim for 80+ lines)
-   - script.js: real interactivity wired to actual element ids from your HTML (aim for 40+ lines)
+   - index.html: semantic HTML5 (header/nav/main/footer), viewport meta, aria-labels
+     on interactive elements, linking styles.css and script.js with defer
+   - styles.css: modern design - custom properties, flexbox/grid layout, responsive
+     media queries, hover/focus states, prefers-color-scheme support (aim for 80+ lines)
+   - script.js: real interactivity wired to actual element ids from your HTML,
+     event listeners + DOM updates (aim for 40+ lines)
 4. Zero placeholders ("TODO", "content here", "..."). Every button and link does something real.
-5. VERIFY each file exists (read_file/list_files), then summarize how to open it.
+5. Unsure about an API or library? Use web_search to check real docs BEFORE writing
+   code that guesses. CDN libs via <script src> are allowed when they help.
+6. VERIFY each file exists (read_file/list_files), then summarize how to open it.
 Do NOT say done until every file from your plan exists on disk.`;
 
 const PROJECT_CODE_BRIEF = `

package/src/cli.js

@@ -11,6 +11,7 @@ const { Agent } = require("./agent");
 const Platform = require("./platform");
 const catalog = require("./catalog");
 const web = require("./web");
+const { renderMarkdown, SmoothPrinter } = require("./render");
 
 // Single source of truth: package.json version + device-build tag.
 const PKG = require("../package.json");
@@ -200,29 +201,36 @@ class CLI {
     const stream = this.cfg.get("ui.stream", true);
     const collected = [];
     this._chatActive = true;
+    let printer = null;
     try {
       if (stream) {
         this._raw("\n");
         this._thinkingStart();
         let thinkingShown = process.stdout.isTTY === true;
+        printer = new SmoothPrinter();
+        printer.begin();
         for await (const chunk of this.agent.runStream(userInput)) {
           if (chunk) {
             if (thinkingShown) { this._thinkingClear(); thinkingShown = false; }
             collected.push(chunk);
-            this._raw(chunk);
+            printer.feed(chunk);
           }
         }
-        // Only clear the indicator - never touch the response text.
+        // Repaints the whole message in place: boxed code, styled markdown.
         if (thinkingShown) { this._thinkingClear(); thinkingShown = false; }
+        printer.finish();
         this._raw("\n");
         web.recordRun(this.agent.lastRun);
         this._timingFooter();
       } else {
         const response = await this.agent.run(userInput);
         web.recordRun(this.agent.lastRun);
-        this.print(response);
+        this.print(process.stdout.isTTY && process.env.TERM !== "dumb"
+          ? renderMarkdown(response, Math.max(40, Math.min(120, (process.stdout.columns || 100) - 2)))
+          : response);
       }
     } catch (e) {
+      if (printer) printer.abort();
       this._raw("\n");
       this.error(`Error: ${e.message}`);
     } finally {

package/src/ollama-setup.js

@@ -0,0 +1,141 @@
+"use strict";
+
+// Local-engine bootstrap (parity with ogpt/utils/ollama_setup.py).
+// Makes `ogpt` work right after install: installs the engine if missing,
+// starts the server daemon, picks a model that fits the RAM, and pulls it -
+// all installer output hidden behind short status lines.
+
+const { spawn, spawnSync } = require("child_process");
+const os = require("os");
+
+function isInstalled() {
+  try {
+    return spawnSync("ollama", ["--version"],
+      { stdio: "ignore", timeout: 15000 }).status === 0;
+  } catch { return false; }
+}
+
+function _getJson(host, path, timeoutMs) {
+  return new Promise((resolve) => {
+    const uri = new URL(path, host);
+    const mod = uri.protocol === "https:" ? require("https") : require("http");
+    const req = mod.request(uri, { timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (c) => { data += c; });
+      res.on("end", () => {
+        try { resolve({ ok: res.statusCode === 200, json: JSON.parse(data) }); }
+        catch { resolve({ ok: false }); }
+      });
+    });
+    req.on("timeout", () => { req.destroy(); resolve({ ok: false }); });
+    req.on("error", () => resolve({ ok: false }));
+    req.end();
+  });
+}
+
+async function serverUp(host, timeoutMs = 2500) {
+  const r = await _getJson(host, "/api/tags", timeoutMs);
+  return r.ok;
+}
+
+async function startServer(host, waitSec = 20) {
+  try {
+    const child = spawn("ollama", ["serve"],
+      { stdio: "ignore", detached: true });
+    child.unref();
+  } catch { return false; }
+  const deadline = Date.now() + waitSec * 1000;
+  while (Date.now() < deadline) {
+    await sleep(500);
+    if (await serverUp(host)) return true;
+  }
+  return false;
+}
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+
+async function listModels(host) {
+  const r = await _getJson(host, "/api/tags", 4000);
+  if (!r.ok || !r.json || !Array.isArray(r.json.models)) return [];
+  return r.json.models.map((m) => m.name || "").filter(Boolean);
+}
+
+async function pullModel(host, model, timeoutSec = 1800) {
+  console.log("Installing packages...");
+  try {
+    spawnSync("ollama", ["pull", model],
+      { stdio: "ignore", timeout: timeoutSec * 1000 });
+  } catch {}
+  const installed = await listModels(host);
+  const base = model.split(":")[0];
+  return installed.includes(model)
+    || installed.some((m) => m.startsWith(base + ":"));
+}
+
+function ramGB() {
+  return Math.round(os.totalmem() / (1024 * 1024 * 1024));
+}
+
+async function pickModel(host, configuredModel) {
+  const installed = await listModels(host);
+  if (installed.includes(configuredModel)) return configuredModel;
+  let fit = null;
+  try {
+    const { recommendForRam } = require("./catalog");
+    fit = recommendForRam(ramGB());
+  } catch {}
+  if (fit && installed.includes(fit)) return fit;
+  if (fit && !installed.length) return fit;          // fresh machine: pull best fit
+  if (installed.length) return installed[0];          // something already there
+  return fit || configuredModel;
+}
+
+/**
+ * Ensure the local engine is installed, running and has a usable model.
+ * Returns {ok, model, reason} - never throws.
+ */
+async function ensureLocalEngine({ host, model } = {}) {
+  host = host || "http://127.0.0.1:11434";
+  model = model || "qwen2.5-coder:1.5b";
+  try {
+    if (!isInstalled()) {
+      console.log("Installing packages...");
+      const { installOllama } = require("./bootstrap");
+      if (!installOllama()) {
+        return { ok: false, reason:
+          "Local engine could not be installed automatically. "
+          + "Grab it from https://ollama.com/download, or pick another "
+          + "provider with /provider." };
+      }
+    }
+    let up = await serverUp(host);
+    if (!up) {
+      console.log("Starting local engine...");
+      up = await startServer(host);
+      if (!up) {
+        return { ok: false, reason:
+          `Local engine did not respond on ${host} within 20s. `
+          + "Try 'ollama serve' manually or check 'journalctl -u ollama'." };
+      }
+    }
+    const chosen = await pickModel(host, model);
+    const installed = await listModels(host);
+    const base = chosen.split(":")[0];
+    const have = installed.includes(chosen)
+      || installed.some((m) => m.startsWith(base + ":"));
+    if (!have) {
+      const okPull = await pullModel(host, chosen);
+      if (!okPull) {
+        return { ok: false, reason:
+          `Model ${chosen} could not be downloaded (offline?). `
+          + "Check your connection or /model to pick an installed one." };
+      }
+    }
+    return { ok: true, model: chosen };
+  } catch (e) {
+    return { ok: false, reason: e.message };
+  }
+}
+
+module.exports = { ensureLocalEngine, serverUp, startServer, listModels,
+  pullModel, pickModel, isInstalled };

package/src/ollama.js

@@ -348,7 +348,16 @@ class OllamaProvider {
           });
         }
       );
-      req.on("error", reject);
+      req.on("error", (e) => {
+        if (e && (e.code === "ECONNREFUSED" || /ECONNREFUSED/.test(e.message || ""))) {
+          reject(new Error(
+            `Local engine is not running at ${this.host}. `
+            + "Start it with 'ollama serve' (OGPT normally does this "
+            + "automatically at launch), or switch providers with /provider."));
+        } else {
+          reject(e);
+        }
+      });
       req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
       if (body) req.write(JSON.stringify(body));
       req.end();
@@ -394,7 +403,16 @@ class OllamaProvider {
           req.destroy(new Error(`No data from the local engine for ${Math.round(this.idleTimeout / 1000)}s`));
         }, this.idleTimeout);
       };
-      req.on("error", (e) => { clearIdle(); reject(e); });
+      req.on("error", (e) => {
+        clearIdle();
+        if (e && e.code === "ECONNREFUSED") {
+          reject(new Error(
+            `Local engine is not running at ${this.host}. `
+            + "Start it with 'ollama serve' or switch providers with /provider."));
+        } else {
+          reject(e);
+        }
+      });
       req.on("close", clearIdle);
       req.write(JSON.stringify(body));
       req.end();

package/src/render.js

@@ -0,0 +1,196 @@
+"use strict";
+
+// Terminal chat renderer, opencode-style:
+//  - live-updating output (SmoothPrinter repaints in place instead of
+//    spilling raw tokens, which is what made streaming feel choppy)
+//  - fenced code blocks drawn as rounded boxes with a language label
+//  - light inline styling: bold/italic, `inline code`, headings, links
+// Everything degrades to plain passthrough when stdout is not a TTY.
+
+const ESC = "\x1b";
+const C = {
+  reset: `${ESC}[0m`, bold: `${ESC}[1m`, dim: `${ESC}[2m`,
+  red: `${ESC}[31m`, green: `${ESC}[32m`, yellow: `${ESC}[33m`,
+  blue: `${ESC}[34m`, magenta: `${ESC}[35m`, cyan: `${ESC}[36m`,
+};
+
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ""); }
+
+function truncateVisible(s, max) {
+  if (visibleWidth(s) <= max) return s;
+  let out = "", w = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === ESC && s[i + 1] === "[") {
+      const m = /\x1b\[[0-9;]*m/.exec(s.slice(i));
+      if (m) { out += m[0]; i += m[0].length - 1; continue; }
+    }
+    w += s.codePointAt(i) > 0xffff ? 2 : 1;
+    if (w > max - 1) return out + C.dim + "…" + C.reset;
+    out += s[i];
+  }
+  return out;
+}
+
+function visibleWidth(s) { return stripAnsi(s).length; }
+
+const KEYWORDS = new Set(("const let var function return if else for while class import " +
+  "from export default async await new try catch throw switch case break continue " +
+  "def lambda elif None True False self public private static void int float str " +
+  "bool this super extends implements package interface type enum struct impl fn " +
+  "match use pub mut nil null true false and or not in is").split(" "));
+
+// Minimal, conservative token tinting for box bodies. Strings first
+// (placeholder-protected), then comments, then keywords.
+function tintCode(line) {
+  const strings = [];
+  line = line.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/g, (m) => {
+    strings.push(m);
+    return `\x00${strings.length - 1}\x00`;
+  });
+  if (/^\s*(\/\/|#|\/\*|\*|--)/.test(line)) {
+    line = C.dim + line + C.reset;
+  } else {
+    line = line.replace(/\b[A-Za-z_][A-Za-z0-9_]*\b/g, (w) =>
+      KEYWORDS.has(w) ? C.magenta + w + C.reset : w);
+    line = line.replace(/\b(\d+(?:\.\d+)?)\b/g, (n) => C.blue + n + C.reset);
+  }
+  line = line.replace(/\x00(\d+)\x00/g, (_, i) => C.yellow + strings[+i] + C.reset);
+  return line;
+}
+
+function padVisible(s, width) {
+  const pad = width - visibleWidth(s);
+  return s + " ".repeat(Math.max(0, pad));
+}
+
+function renderCodeBox(lang, lines, width) {
+  const inner = Math.max(20, width - 4);
+  const label = (lang || "").trim();
+  const top = label
+    ? `╭─ ${C.cyan}${label}${C.reset} ${"─".repeat(Math.max(1, inner - label.length - 4))}`
+    : `╭─${"─".repeat(inner - 1)}`;
+  const body = lines.map((l) =>
+    `${C.dim}│${C.reset} ` + padVisible(truncateVisible(tintCode(l), inner), inner) + ` ${C.dim}│${C.reset}`);
+  return [top + C.dim + "╮" + C.reset, ...body,
+    C.dim + "╰" + "─".repeat(inner + 2) + "╯" + C.reset];
+}
+
+function renderInline(s) {
+  return s
+    .replace(/\*\*([^*]+)\*\*/g, `${C.bold}$1${C.reset}`)
+    .replace(/(^|\s)\*([^*\s][^*]*)\*/g, `$1${C.dim}$2${C.reset}`)
+    .replace(/`([^`]+)`/g, `${C.cyan}$1${C.reset}`)
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, `$1 ${C.dim}($2)${C.reset}`);
+}
+
+/**
+ * Render a full assistant message for the terminal.
+ * Fenced blocks become rounded boxes; prose gets light markdown styling.
+ * Lines are hard-truncated to the given width so repaint math stays exact.
+ */
+function renderMarkdown(text, width = 100) {
+  width = Math.max(40, Math.min(120, width));
+  const src = String(text ?? "").split("\n");
+  const out = [];
+  let inFence = false, lang = "", buf = [];
+  const flushFence = () => {
+    out.push(...renderCodeBox(lang, buf, width));
+    buf = []; lang = "";
+  };
+  for (const line of src) {
+    const m = /^\s*```(.*)$/.exec(line);
+    if (m) {
+      if (inFence) { flushFence(); inFence = false; }
+      else { inFence = true; lang = m[1]; }
+      continue;
+    }
+    if (inFence) { buf.push(line); continue; }
+    const h = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (h) {
+      out.push(C.bold + C.cyan + h[2] + C.reset);
+      continue;
+    }
+    if (/^\s*(-{3,}|={3,}|\*{3,})\s*$/.test(line)) {
+      out.push(C.dim + "─".repeat(width) + C.reset);
+      continue;
+    }
+    if (/^\s*&gt;\s?/.test(line)) { out.push(C.dim + line + C.reset); continue; }
+    out.push(truncateVisible(renderInline(line), width));
+  }
+  if (inFence) flushFence();
+  return out.join("\n");
+}
+
+const MAX_PREVIEW_CHARS = 60000;
+
+/**
+ * In-place repainting stream target. TTY: buffers chunks and repaints the
+ * rendered message every ~50ms (opencode feel). Non-TTY: raw passthrough.
+ */
+class SmoothPrinter {
+  constructor(out = process.stdout) {
+    this.out = out;
+    this.tty = !!(out.isTTY && process.env.TERM !== "dumb"
+      && !process.env.OGPT_PLAIN);
+    this.width = Math.max(40, Math.min(120, (out.columns || 100) - 2));
+  }
+
+  begin() {
+    this.buf = "";
+    this.drawn = 0;
+    this.lastPaint = 0;
+    this.timer = null;
+    if (!this.tty) return;
+    // Hide the cursor while we repaint to avoid flicker.
+    this.out.write(`${ESC}[?25l`);
+  }
+
+  feed(chunk) {
+    if (!this.tty) { this.out.write(chunk); return; }
+    this.buf += chunk;
+    if (this.buf.length > MAX_PREVIEW_CHARS * 1.5) {
+      this.buf = this.buf.slice(-MAX_PREVIEW_CHARS);
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => { this.timer = null; this._paint(); }, 50);
+    }
+  }
+
+  _erase() {
+    if (this.drawn > 0) this.out.write(`${ESC}[${this.drawn}A${ESC}[J`);
+    this.drawn = 0;
+  }
+
+  _paint() {
+    if (!this.tty || this.closed) return;
+    const now = Date.now();
+    if (now - this.lastPaint < 45) return;
+    this._erase();
+    let preview = this.buf;
+    if (preview.length > MAX_PREVIEW_CHARS) preview = preview.slice(-MAX_PREVIEW_CHARS);
+    const rendered = renderMarkdown(preview, this.width);
+    this.out.write(rendered);
+    this.drawn = rendered.split("\n").length - 1;
+    this.lastPaint = now;
+  }
+
+  finish() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
+    if (!this.tty) return;
+    this._erase();
+    this.out.write(renderMarkdown(this.buf, this.width) + "\n");
+    this.out.write(`${ESC}[?25h`);
+  }
+
+  abort() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.timer) { clearTimeout(this.timer); this.timer = null; }
+    if (!this.tty) return;
+    this.out.write("\n" + `${ESC}[?25h`);
+  }
+}
+
+module.exports = { renderMarkdown, SmoothPrinter, tintCode, visibleWidth };

package/src/tools.js

@@ -59,6 +59,18 @@ const TOOL_ALIASES = {
   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",
+  writefolder: "make_dir", write_folder: "make_dir", writefolderfile: "make_dir",
+  // move / copy / delete
+  move: "move_path", mv: "move_path", rename: "move_path", rename_file: "move_path",
+  renamefile: "move_path", movefile: "move_path", move_file: "move_path",
+  movefolder: "move_path", move_folder: "move_path", movepath: "move_path",
+  copy: "copy_path", cp: "copy_path", copyfile: "copy_path", copy_file: "copy_path",
+  copyfolder: "copy_path", copy_folder: "copy_path", copypath: "copy_path",
+  duplicate: "copy_path", dup: "copy_path",
+  delete: "delete_path", del: "delete_path", rm: "delete_path", remove: "delete_path",
+  removefile: "delete_path", remove_file: "delete_path", deletefile: "delete_path",
+  delete_file: "delete_path", deletefolder: "delete_path", delete_folder: "delete_path",
+  rmdir: "delete_path", unlink: "delete_path", trash: "delete_path",
   // file writing
   writefile: "write_file", filewrite: "write_file", createfile: "write_file",
   create_file: "write_file", newfile: "write_file", new_file: "write_file",
@@ -555,6 +567,20 @@ const TOOLS = [
     "Create a folder/directory (nested parents are created automatically)", {
       type: "object", properties: { path: { type: "string" } }, required: ["path"],
     }),
+  new ToolDef("move_path",
+    "Move or rename a file/folder (destination folder is created if needed)", {
+      type: "object",
+      properties: { source: { type: "string" }, destination: { type: "string" } },
+      required: ["source", "destination"],
+    }, true),
+  new ToolDef("copy_path", "Copy a file or whole folder", {
+    type: "object",
+    properties: { source: { type: "string" }, destination: { type: "string" } },
+    required: ["source", "destination"],
+  }),
+  new ToolDef("delete_path", "Delete a file or folder (recursive)", {
+    type: "object", properties: { path: { type: "string" } }, required: ["path"],
+  }, true),
   new ToolDef("edit_file", "Replace exact text in file", {
     type: "object",
     properties: {
@@ -747,8 +773,11 @@ const IMPLEMENTATIONS = {
           "/* Styles */\n\n" +
           ":root {\n" +
           "  --bg: #0f172a;\n" +
+          "  --surface: #1e293b;\n" +
           "  --fg: #e2e8f0;\n" +
+          "  --muted: #94a3b8;\n" +
           "  --accent: #38bdf8;\n" +
+          "  --radius: 12px;\n" +
           "}\n\n" +
           "*,\n*::before,\n*::after {\n" +
           "  box-sizing: border-box;\n" +
@@ -758,9 +787,35 @@ const IMPLEMENTATIONS = {
           "  font-family: system-ui, sans-serif;\n" +
           "  background: var(--bg);\n" +
           "  color: var(--fg);\n" +
-          "  line-height: 1.6;\n}\n";
+          "  line-height: 1.6;\n}\n\n" +
+          ".container {\n" +
+          "  max-width: 960px;\n" +
+          "  margin: 0 auto;\n" +
+          "  padding: 1.5rem;\n}\n\n" +
+          ".card {\n" +
+          "  background: var(--surface);\n" +
+          "  border-radius: var(--radius);\n" +
+          "  padding: 1.25rem;\n}\n\n" +
+          "button,\n.btn {\n" +
+          "  background: var(--accent);\n" +
+          "  color: #06283d;\n" +
+          "  border: none;\n" +
+          "  border-radius: var(--radius);\n" +
+          "  padding: 0.6rem 1.2rem;\n" +
+          "  font-weight: 600;\n" +
+          "  cursor: pointer;\n}\n\n" +
+          "button:hover,\n.btn:hover { filter: brightness(1.1); }\n\n" +
+          "@media (prefers-color-scheme: light) {\n" +
+          "  :root {\n    --bg: #f8fafc;\n    --surface: #ffffff;\n    --fg: #0f172a;\n    --muted: #64748b;\n  }\n}\n\n" +
+          "@media (max-width: 600px) {\n" +
+          "  .container { padding: 1rem; }\n}\n";
       } else if (ext === ".js") {
-        content = "// App scripts\n\"use strict\";\n";
+        content =
+          "// App scripts\n\"use strict\";\n\n" +
+          "document.addEventListener(\"DOMContentLoaded\", () => {\n" +
+          "  const $ = (sel) => document.querySelector(sel);\n\n" +
+          "  // Wire your UI here - every element id in index.html can be grabbed with $(\"#id\").\n" +
+          "});\n";
       }
     }
     fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -787,6 +842,55 @@ const IMPLEMENTATIONS = {
     return new ToolResult(`Created directory: ${p}`);
   },
 
+  move_path(args) {
+    const src = path.resolve(anchorPath(String(args.source || args.path || "")).replace(/^~(?=$|\/)/, os.homedir()));
+    let dst = String(args.destination || args.dest || args.to || "").trim();
+    if (!src || !dst) return new ToolResult("", "move_path needs 'source' and 'destination'", false);
+    dst = path.resolve(dst.replace(/^~(?=$|\/)/, os.homedir()));
+    if (!fs.existsSync(src)) return new ToolResult("", `Not found: ${src}`, false);
+    if (fs.existsSync(dst) && fs.statSync(dst).isDirectory()) {
+      dst = path.join(dst, path.basename(src));
+    }
+    if (dst === src) return new ToolResult(`Unchanged: ${src}`);
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    try {
+      fs.renameSync(src, dst);
+    } catch { // cross-device: copy + remove
+      fs.cpSync(src, dst, { recursive: true });
+      fs.rmSync(src, { recursive: true, force: true });
+    }
+    const kind = fs.statSync(dst).isDirectory() ? "directory" : "file";
+    return new ToolResult(`Moved ${kind}: ${src} -> ${dst}`);
+  },
+
+  copy_path(args) {
+    const src = path.resolve(String(args.source || args.path || "").replace(/^~(?=$|\/)/, os.homedir()));
+    let dst = String(args.destination || args.dest || args.to || "").trim();
+    if (!src || !dst) return new ToolResult("", "copy_path needs 'source' and 'destination'", false);
+    dst = path.resolve(dst.replace(/^~(?=$|\/)/, os.homedir()));
+    if (!fs.existsSync(src)) return new ToolResult("", `Not found: ${src}`, false);
+    if (fs.existsSync(dst) && fs.statSync(dst).isDirectory()) {
+      dst = path.join(dst, path.basename(src));
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.cpSync(src, dst, { recursive: true });
+    const kind = fs.statSync(dst).isDirectory() ? "directory" : "file";
+    return new ToolResult(`Copied ${kind}: ${src} -> ${dst}`);
+  },
+
+  delete_path(args) {
+    const raw = String(args.path || "").trim();
+    if (!raw) return new ToolResult("", "Empty path", false);
+    const p = path.resolve(raw.replace(/^~(?=$|\/)/, os.homedir()));
+    if (p === path.parse(p).root || p === os.homedir() || p === process.cwd()) {
+      return new ToolResult("", `Refusing to delete '${p}' - it is a protected root.`, false);
+    }
+    if (!fs.existsSync(p)) return new ToolResult(`Already gone: ${p}`);
+    const kind = fs.statSync(p).isDirectory() ? "directory" : "file";
+    fs.rmSync(p, { recursive: true, force: true });
+    return new ToolResult(`Deleted ${kind}: ${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);