@krmxd/onegpt 0.1.9-beta → 0.2.1-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krmxd/onegpt",
-  "version": "0.1.9-beta",
+  "version": "0.2.1-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 " +
@@ -128,7 +131,15 @@ const EXECUTE_NUDGE =
 
 function wantsAction(userInput) {
   // True when the user asked for something to be built (not explained).
-  return TASK_RE.test(userInput) && !QUESTION_RE.test(userInput.trim());
+  const t = String(userInput || "").trim();
+  const tm = TASK_RE.exec(t);
+  if (!tm) return false;
+  // A question word BEFORE the build verb means they're ASKING, not
+  // requesting work: "how do I fix the login bug?" must be answered,
+  // not turned into a flurry of file edits.
+  const qm = /\b(how|what|why|when|where|which|who|whom|explain|describe)\b/i.exec(t);
+  if (qm && qm.index < tm.index) return false;
+  return true;
 }
 
 function redirectMsg(task) {
@@ -214,11 +225,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 = `
@@ -623,8 +639,11 @@ class Agent {
         // Self-correction: instructions/code instead of done work gets one
         // firm push to act - on ANY round, not just the first (tiny models
         // relapse into how-to mode mid-task). An EMPTY reply after partial
-        // work means it stalled - push it too.
-        const replyLazy = repliedWithoutActing(resp.content);
+        // work means it stalled - push it too. BUT a reply is never "lazy"
+        // once real work happened this turn: closing summaries often quote
+        // commands in fences ("run it with ```npm start```") - nudging then
+        // made the model edit files over and over instead of answering.
+        const replyLazy = repliedWithoutActing(resp.content) && doneBits.length === 0;
         const wentSilent = !resp.content.trim() && (rounds > 1 || doneBits.length > 0);
         if (nudges < 3 && !this._cancelled
             && wantsAction(userInput) && (replyLazy || wentSilent || stalledHalfway(resp.content, userInput, doneBits))) {
@@ -776,8 +795,11 @@ class Agent {
         // Self-correction: instructions/code instead of done work gets one
         // firm push to act - on ANY round, not just the first (tiny models
         // relapse into how-to mode mid-task). An EMPTY reply after partial
-        // work means it stalled - push it too.
-        const replyLazy = repliedWithoutActing(full);
+        // work means it stalled - push it too. BUT a reply is never "lazy"
+        // once real work happened this turn: closing summaries often quote
+        // commands in fences ("run it with ```npm start```") - nudging then
+        // made the model edit files over and over instead of answering.
+        const replyLazy = repliedWithoutActing(full) && doneBits.length === 0;
         const wentSilent = !full.trim() && (rounds > 1 || doneBits.length > 0);
         if (nudges < 3 && !this._cancelled
             && wantsAction(userInput) && (replyLazy || wentSilent || stalledHalfway(full, userInput, doneBits))) {
@@ -884,4 +906,4 @@ class Agent {
   }
 }
 
-module.exports = { Agent, extractJsonTools, repairToolJson };
+module.exports = { Agent, extractJsonTools, repairToolJson, wantsAction, repliedWithoutActing, stalledHalfway };

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/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);