@krmxd/onegpt 0.0.0-beta

package/src/cli.js

@@ -0,0 +1,1111 @@
+"use strict";
+
+const readline = require("readline");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { getConfig } = require("./config");
+const { getSharedProvider } = require("./ollama");
+const { ToolRegistry } = require("./tools");
+const { Agent } = require("./agent");
+const Platform = require("./platform");
+const catalog = require("./catalog");
+const web = require("./web");
+
+const VERSION = "1.1.0";
+
+class Command {
+  constructor(name, handler, description, usage, category, ai, aliases) {
+    this.name = name;
+    this.handler = handler; // (args: string[]) => void|Promise<void>
+    this.description = description;
+    this.usage = usage || name;
+    this.category = category || "general";
+    this.ai = !!ai; // safe for the AI to execute via its ogpt_command tool
+    this.aliases = aliases || [];
+  }
+}
+
+class CLI {
+  constructor(options = {}) {
+    this.cfg = options.config || getConfig();
+    this.tools = options.tools || new ToolRegistry();
+    this.agent = new Agent({ config: this.cfg, tools: this.tools });
+    this.host = (this.cfg.get("ollama.host", "http://127.0.0.1:11434") || "").replace(/localhost/g, "127.0.0.1");
+    this.running = true;
+    this._capture = null; // when set, output is captured for the AI
+    this._warmupBusy = false;
+    this._chatActive = false; // suppress background prints while a reply streams
+    this._replStarted = false; // suppress background prints once the REPL takes input
+    this._registerCommands();
+    // Let the AI execute internal commands through its own tool
+    this.tools.commandDispatcher = (cmd) => this.runAiCommand(cmd);
+  }
+
+  get provider() {
+    return getSharedProvider(this.host);
+  }
+
+  // ------------------------------------------------------------------ output
+
+  _emit(msg) {
+    if (this._capture !== null) {
+      this._capture.push(String(msg).replace(/\x1b\[[0-9;]*m/g, ""));
+      return;
+    }
+    process.stdout.write(msg + "\n");
+  }
+
+  print(msg) {
+    this._emit(msg ?? "");
+  }
+
+  printColor(color, msg) {
+    const colors = { red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", magenta: "\x1b[35m", dim: "\x1b[2m", bold: "\x1b[1m" };
+    if (this._capture !== null) {
+      this._capture.push(String(msg));
+      return;
+    }
+    const c = colors[color] || "";
+    process.stdout.write(`${c}${msg}\x1b[0m\n`);
+  }
+
+  error(msg) { this.printColor("red", `✗ ${msg}`); }
+  success(msg) { this.printColor("green", `✓ ${msg}`); }
+  info(msg) { this.printColor("cyan", `ℹ ${msg}`); }
+  warn(msg) { this.printColor("yellow", `⚠ ${msg}`); }
+
+  _raw(msg) {
+    if (this._capture !== null) {
+      this._capture.push(msg);
+      return;
+    }
+    process.stdout.write(msg);
+  }
+
+  _table(title, columns, rows) {
+    if (this._capture !== null) {
+      const widths = columns.map((c) => c.length);
+      for (const row of rows) {
+        row.forEach((cell, i) => { widths[i] = Math.max(widths[i], String(cell ?? "").length); });
+      }
+      const lines = ["  " + columns.map((c, i) => String(c).padEnd(widths[i])).join("  ")];
+      lines.push("  " + widths.map((w) => "-".repeat(w)).join("  "));
+      for (const row of rows) {
+        lines.push("  " + row.map((cell, i) => String(cell ?? "").padEnd(widths[i])).join("  "));
+      }
+      this._capture.push(title + "\n" + lines.join("\n"));
+      return;
+    }
+    // columnar layout with ANSI-aware padding
+    const strip = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, "");
+    const widths = columns.map((c) => strip(c).length);
+    for (const row of rows) {
+      row.forEach((cell, i) => { widths[i] = Math.max(widths[i], strip(cell).length); });
+    }
+    const line = (cells, padChar) =>
+      "  " + cells.map((cell, i) => {
+        const s = String(cell);
+        return s + padChar.repeat(widths[i] - strip(s).length);
+      }).join("  ");
+    this.print("");
+    this.printColor("bold", `  ${title}`);
+    this.print(line(columns, " "));
+    this.print(line(widths.map((w) => "─".repeat(w)), "─").replace(/─/g, "─"));
+    for (const row of rows) this.print(line(row, " "));
+    this.print("");
+  }
+
+  // ------------------------------------------------------------------ splash & prompt
+
+  splash() {
+    const model = this.cfg.displayName();
+    const tier = Platform.recommendTier();
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    const tty = process.stdout.isTTY === true;
+    const C = "\x1b[36m", B = "\x1b[1m", D = "\x1b[2m", W = "\x1b[37m", R = "\x1b[0m";
+
+    // Fresh start: wipe whatever was on screen, then draw the banner centered.
+    if (tty) process.stdout.write("\x1b[2J\x1b[H");
+
+    const center = (s) => {
+      const pad = Math.max(0, Math.floor((cols - s.length) / 2));
+      return " ".repeat(pad) + s;
+    };
+    const art = [
+      "  ___  ____  _____ _   _ ______   __",
+      " / _ \\/ __ \\| ____| \\ | |  _ \\ \\ / /",
+      "| | | |  | |  _| |  \\| | | | \\ V /",
+      "| |_| |__| | |___| |\\  | |_| || |",
+      " \\___/ \\____/|_____|_| \\_|____/ |_|",
+    ];
+    if (tty) {
+      const lines = [""];
+      for (const l of art) lines.push(`${B}${C}${center(l)}${R}`);
+      lines.push("");
+      lines.push(`${B}${W}${center(`AI coding assistant by KareemXD · v${VERSION}`)}${R}`);
+      lines.push(`${B}${C}${center(`Active model: ${model} · ${Platform.ramGB()}GB RAM · tier ${tier}`)}${R}`);
+      lines.push(`${D}${center("Type /help for commands · /quit to exit")}${R}`);
+      lines.push("", "");
+      const vpad = Math.max(0, Math.floor((rows - lines.length) / 2) - 1);
+      process.stdout.write("\n".repeat(vpad) + lines.join("\n") + "\n\n");
+    } else {
+      const out = [...art, "", center(`OGPT v${VERSION} · model: ${model} · ${Platform.ramGB()}GB RAM · tier ${tier}`), center("Type /help for commands, /quit to exit"), ""];
+      process.stdout.write(out.join("\n") + "\n");
+    }
+  }
+
+  prompt() {
+    const model = this.cfg.displayName();
+    return `\x1b[1;36m${model}\x1b[0m \x1b[36m❯\x1b[0m `;
+  }
+
+  // ------------------------------------------------------------------ chat rendering
+
+  _thinkingStart() {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1b[2m● thinking...\x1b[0m");
+    }
+  }
+
+  _thinkingClear() {
+    if (process.stdout.isTTY) process.stdout.write("\r\x1b[K");
+  }
+
+  _timingFooter() {
+    if (!this.cfg.get("ui.timing", true)) return;
+    const s = this.agent.lastRun || {};
+    const parts = [];
+    if (s.tokens) parts.push(`${s.tokens} tok`);
+    if (s.tps) parts.push(`${s.tps} tok/s`);
+    if (s.ttft !== undefined) parts.push(`first token ${Number(s.ttft).toFixed(2)}s`);
+    if (s.duration) parts.push(`total ${Number(s.duration).toFixed(1)}s`);
+    let cwd = process.cwd();
+    try {
+      const home = require("os").homedir();
+      if (cwd.startsWith(home)) cwd = "~" + cwd.slice(home.length);
+    } catch {}
+    parts.push(cwd);
+    const dim = process.stdout.isTTY ? "\x1b[2m" : "";
+    const rst = process.stdout.isTTY ? "\x1b[0m" : "";
+    this._raw(`${dim}· ${this.cfg.displayName()} · ${parts.join(" · ")}${rst}\n`);
+  }
+
+  async _chat(userInput) {
+    const stream = this.cfg.get("ui.stream", true);
+    const collected = [];
+    this._chatActive = true;
+    try {
+      if (stream) {
+        this._raw("\n");
+        this._thinkingStart();
+        let thinkingShown = process.stdout.isTTY === true;
+        for await (const chunk of this.agent.runStream(userInput)) {
+          if (chunk) {
+            if (thinkingShown) { this._thinkingClear(); thinkingShown = false; }
+            collected.push(chunk);
+            this._raw(chunk);
+          }
+        }
+        // Only clear the indicator - never touch the response text.
+        if (thinkingShown) { this._thinkingClear(); thinkingShown = false; }
+        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);
+      }
+    } catch (e) {
+      this._raw("\n");
+      this.error(`Error: ${e.message}`);
+    } finally {
+      this._chatActive = false;
+    }
+  }
+
+  // ------------------------------------------------------------------ command registry
+
+  _registerCommands() {
+    const reg = (cmd) => { this.commands[cmd.name] = cmd; };
+    this.commands = {};
+
+    reg(new Command("/help", (a) => this.cmdHelp(a), "Show commands (use /help <cmd> for details)", "/help [command]", "general", true, ["/?", "/h"]));
+    reg(new Command("/quit", () => { this.running = false; this.print("Goodbye!"); }, "Exit OGPT", "/quit", "general", false, ["/exit", "/q"]));
+    reg(new Command("/clear", () => { this.agent.clear(); this.success("Conversation cleared."); }, "Clear conversation history", "/clear", "general"));
+    reg(new Command("/cls", () => { process.stdout.write("\x1b[2J\x1b[H"); }, "Clear the terminal screen", "/cls", "general"));
+    reg(new Command("/multi", () => this.cmdMulti(), "Enter multi-line input (empty line to finish)", "/multi", "general"));
+
+    reg(new Command("/status", () => this.cmdStatus(), "Show current status", "/status", "model", true));
+    reg(new Command("/model", (a) => this.cmdModel(a), "Switch model by oGPT name or id", "/model <oGPT-name|id>", "model", true));
+    reg(new Command("/models", () => this.cmdModels(), "List installed models", "/models", "model", true));
+    reg(new Command("/catalog", () => this.cmdCatalog(), "Show curated oGPT model catalog", "/catalog", "model", true));
+    reg(new Command("/pull", (a) => this.cmdPull(a), "Download a model (with progress)", "/pull <oGPT-name|id>", "model"));
+    reg(new Command("/ps", () => this.cmdPs(), "Show models loaded in memory", "/ps", "model", true));
+    reg(new Command("/warmup", (a) => this.cmdWarmup(a), "Preload the active model into memory", "/warmup", "model", true));
+
+    reg(new Command("/save", () => this.cmdSave(), "Save the current session", "/save", "session", true));
+    reg(new Command("/load", (a) => this.cmdLoad(a), "Load a saved session by id", "/load <id>", "session"));
+    reg(new Command("/sessions", () => this.cmdSessions(), "List saved sessions", "/sessions", "session"));
+    reg(new Command("/session", (a) => this.cmdSession(a), "Manage sessions", "/session new|save|list|load|delete <id>", "session"));
+    reg(new Command("/new", (a) => this.cmdNew(a), "Archive current chat and start a fresh one", "/new [title]", "general"));
+    reg(new Command("/fresh", (a) => this.cmdNew(a), "Alias of /new - start a fresh chat", "/fresh [title]", "general"));
+    reg(new Command("/reset", () => this.cmdReset(), "Reset conversation, memory and sessions", "/reset", "general"));
+    reg(new Command("/dash", async () => {
+      const url = await web.startDashboard(this).catch(() => null);
+      if (url) this.print(`Token dashboard running at ${url}`);
+      else this.printColor("dim", "Dashboard unavailable - set web.enabled=true in config");
+    }, "Show (or start) the token dashboard URL", "/dash"));
+    reg(new Command("/deny", () => {
+      this.tools._perm.auto_approve = false;
+      this.tools._perm.allowed.clear();
+      this.success("Auto-approve disabled.");
+    }, "Disable auto-approve", "/deny", "tools"));
+    reg(new Command("/provider", (a) => this.cmdProvider(a), "List or switch providers", "/provider [name]", "model"));
+    reg(new Command("/context", (a) => this.cmdContext(a), "Show the current conversation messages", "/context [n]", "general", true));
+    reg(new Command("/verbose", () => {
+      const cur = !!this.cfg.get("agent.verbose", false);
+      this.cfg.set("agent.verbose", !cur);
+      this.success(`Verbose: ${!cur ? "ON" : "OFF"}`);
+    }, "Toggle verbose mode", "/verbose", "settings"));
+    reg(new Command("/panel", () => {
+      const cur = !!this.cfg.get("ui.panel", true);
+      this.cfg.set("ui.panel", !cur);
+      this.success(`Panel UI: ${!cur ? "ON" : "OFF"} (restart applies)`);
+    }, "Toggle the chat panel UI (restart applies)", "/panel", "settings"));
+    reg(new Command("/index", () => this.cmdIndex(), "Show project structure", "/index", "project", true));
+    reg(new Command("/skills", () => this.info("No skills installed. Drop folders into ~/.config/ogpt/skills."),
+      "List available skills", "/skills", "system", true));
+    reg(new Command("/hooks", () => this.info("No hooks registered."),
+      "List registered hooks", "/hooks", "system", true));
+    reg(new Command("/plugins", () => this.info("No plugins loaded."),
+      "List plugins", "/plugins", "system", true));
+    reg(new Command("/mcp", () => this.info("No MCP servers configured."),
+      "List MCP servers", "/mcp", "system", true));
+
+    reg(new Command("/tools", () => this.cmdTools(), "List available tools", "/tools", "tools", true));
+    reg(new Command("/approve", (a) => { this.print(this.tools.toggleApprove(a[0] || "")); }, "Auto-approve a specific tool", "/approve <tool>", "tools"));
+    reg(new Command("/auto", () => { this.print(this.tools.toggleApprove()); }, "Toggle auto-approve for all tools", "/auto", "tools"));
+
+    reg(new Command("/history", (a) => this.cmdHistory(a), "Show conversation history", "/history [n]", "general", true));
+    reg(new Command("/compact", (a) => this.cmdCompact(a), "Compact conversation into a summary", "/compact [keep-n]", "general"));
+    reg(new Command("/undo", () => this.cmdUndo(), "Remove the last exchange from context", "/undo", "general"));
+    reg(new Command("/retry", () => this.cmdRetry(), "Regenerate the last reply", "/retry", "general"));
+
+    reg(new Command("/memory", (a) => this.cmdMemory(a), "Project memory: show/add/search/clear", "/memory [add <text>|search <q>|clear]", "project", true));
+    reg(new Command("/task", (a) => this.cmdTask(a), "Tasks: list/new/update", "/task list|new <desc>|update <id> <status>", "project", true));
+
+    reg(new Command("/config", () => this.cmdConfig(), "Show configuration", "/config", "system"));
+    reg(new Command("/tier", () => this.cmdTier(), "Show recommended model tier", "/tier", "system", true));
+    reg(new Command("/stats", () => this.cmdStats(), "Show usage statistics", "/stats", "system", true));
+
+    reg(new Command("/stream", () => this.cmdToggle("ui.stream", "Streaming"), "Toggle streaming responses", "/stream", "settings"));
+    reg(new Command("/timing", () => this.cmdToggle("ui.timing", "Timing footer"), "Toggle perf timing footer", "/timing", "settings"));
+    reg(new Command("/preview", () => this.cmdToggle("ui.preview", "Code preview"), "Toggle code preview on writes", "/preview", "settings"));
+    reg(new Command("/alias", (a) => this.cmdAlias(a), "Create command shortcuts", "/alias [name </command>|remove name]", "settings"));
+
+    // Quick prompt templates
+    reg(new Command("/ask", this._mkPromptCmd("ask"), "Quick question - answer only, no tools", "/ask <question>", "prompts"));
+    reg(new Command("/fix", this._mkPromptCmd("fix"), "Fix code or an error you paste", "/fix <code|error>", "prompts"));
+    reg(new Command("/explain", this._mkPromptCmd("explain"), "Explain code or a concept", "/explain <topic|code>", "prompts"));
+    reg(new Command("/test", this._mkPromptCmd("test"), "Write tests for given code", "/test <code|file>", "prompts"));
+    reg(new Command("/review", () => this.cmdReview(), "Review uncommitted changes (git diff)", "/review", "prompts"));
+    reg(new Command("/optimize", this._mkPromptCmd("optimize"), "Optimize given code", "/optimize <code>", "prompts"));
+    reg(new Command("/doc", this._mkPromptCmd("doc"), "Document given code", "/doc <code>", "prompts"));
+  }
+
+  _mkPromptCmd(kind) {
+    const templates = {
+      ask: "Answer the following question directly and concisely. Do not use any tools.\n\n{}",
+      fix: "Fix the following code or error. Explain the root cause briefly, then provide the corrected code.\n\n{}",
+      explain: "Explain the following in clear detail, step by step where useful:\n\n{}",
+      test: "Write comprehensive unit tests for the following code. Include edge cases.\n\n{}",
+      optimize: "Optimize the following code for performance and readability. Show the improved version and summarize the changes.\n\n{}",
+      doc: "Add clear documentation (docstrings/comments) to the following code. Return the fully documented code.\n\n{}",
+    };
+    const template = templates[kind];
+    return async (args) => {
+      const text = args.join(" ").trim();
+      if (!text) { this.error(`Usage: /${kind} <text>`); return; }
+      await this._chat(template.replace("{}", text));
+    };
+  }
+
+  _resolveAlias(line) {
+    const spaceIdx = line.indexOf(" ");
+    const cmd = (spaceIdx === -1 ? line : line.slice(0, spaceIdx)).toLowerCase();
+    const rest = spaceIdx === -1 ? "" : line.slice(spaceIdx + 1);
+    const alias = (this.cfg.get("aliases", {}) || {})[cmd];
+    if (alias) return `${alias} ${rest}`.trim();
+    return line;
+  }
+
+  _findCommand(name) {
+    const cmd = this.commands[name.toLowerCase()];
+    if (cmd) return cmd;
+    for (const c of Object.values(this.commands)) {
+      if (c.aliases.includes(name.toLowerCase())) return c;
+    }
+    return null;
+  }
+
+  async processCommand(input) {
+    if (!input.startsWith("/")) return false;
+    input = this._resolveAlias(input);
+    const parts = input.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
+
+    const command = this._findCommand(cmd);
+    if (!command) {
+      this.error(`Unknown command: ${cmd}. Type /help for available commands.`);
+      return true;
+    }
+    try {
+      await command.handler(args);
+    } catch (e) {
+      this.error(`Command error: ${e.message}`);
+    }
+    return true;
+  }
+
+  // ------------------------------------------------------------------ AI command bridge
+
+  runAiCommand(line) {
+    line = String(line || "").trim();
+    if (!line.startsWith("/")) line = "/" + line;
+    const parts = line.split(/\s+/);
+    const command = this._findCommand(parts[0]);
+    if (!command) return `Unknown command: ${parts[0]}. Type /help for available commands.`;
+    if (!command.ai) return `Command ${command.name} is not available to the AI.`;
+    this._capture = [];
+    try {
+      const result = command.handler(parts.slice(1));
+      if (result && typeof result.then === "function") {
+        // async handlers need sync dispatch - not supported for AI
+        return `Command ${command.name} could not be completed synchronously.`;
+      }
+      return this._capture.join("\n").trim() || "OK";
+    } catch (e) {
+      return `Error: ${e.message}`;
+    } finally {
+      this._capture = null;
+    }
+  }
+
+  // ------------------------------------------------------------------ general commands
+
+  cmdHelp(args) {
+    if (args && args.length) {
+      const target = this._resolveAlias(args[0]);
+      const command = this._findCommand(target);
+      if (!command) { this.error(`Unknown command: ${args[0]}`); return; }
+      const lines = [
+        `## ${command.name}${command.ai ? " 🤖" : ""}`,
+        "",
+        command.description,
+        "",
+        `**Usage:** \`${command.usage}\``,
+      ];
+      if (command.aliases.length) lines.push(`**Aliases:** ${command.aliases.join(", ")}`);
+      this.print(lines.join("\n"));
+      return;
+    }
+    const titles = {
+      general: "General", model: "Models & Providers", session: "Sessions",
+      tools: "Tools & Permissions", project: "Memory & Tasks", system: "System",
+      settings: "Settings", prompts: "Quick Prompts",
+    };
+    const cats = {};
+    for (const cmd of Object.values(this.commands).sort((a, b) => a.name.localeCompare(b.name))) {
+      (cats[cmd.category] = cats[cmd.category] || []).push(cmd);
+    }
+    const lines = ["  OGPT Commands  (🤖 = also usable by the AI)", ""];
+    for (const [cat, cmds] of Object.entries(cats)) {
+      lines.push(`  ${titles[cat] || cat}:`);
+      for (const cmd of cmds) {
+        const mark = cmd.ai ? " 🤖" : "";
+        lines.push(`    ${cmd.usage.padEnd(42)}${D()} ${cmd.description}${mark}${R()}`);
+      }
+      lines.push("");
+    }
+    this.print(lines.join("\n"));
+  }
+
+  cmdMulti() {
+    return new Promise((resolve) => {
+      this.info("Multi-line mode - finish with an empty line:");
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+      const lines = [];
+      rl.on("line", (line) => {
+        if (!line.trim()) { rl.close(); return; }
+        lines.push(line);
+      });
+      rl.on("close", async () => {
+        if (lines.length) await this._chat(lines.join("\n"));
+        resolve();
+      });
+    });
+  }
+
+  cmdHistory(args) {
+    const n = args && args[0] && !isNaN(args[0]) ? parseInt(args[0]) : 20;
+    const msgs = this.agent.history.filter((m) => m.role !== "tool");
+    if (!msgs.length) { this.print("No conversation history."); return; }
+    msgs.slice(-n).forEach((m, i) => {
+      const icon = m.role === "user" ? "🧑" : "🤖";
+      const content = m.content.length > 120 ? m.content.slice(0, 120) + "..." : m.content.replace(/\n/g, " ");
+      this.print(`${i + 1}. ${icon} ${m.role}: ${content}`);
+    });
+  }
+
+  cmdUndo() {
+    if (this.agent.undo()) this.success("Removed last exchange from context.");
+    else this.print("Nothing to undo.");
+  }
+
+  async cmdRetry() {
+    const last = this.agent.retry();
+    if (last === null) { this.print("Nothing to retry."); return; }
+    this.info(`Retrying: ${last.slice(0, 80)}`);
+    await this._chat(last);
+  }
+
+  cmdCompact(args) {
+    const keep = args[0] && !isNaN(args[0]) ? parseInt(args[0]) : 4;
+    const removed = this.agent.compact(keep);
+    if (removed) this.success(`Compacted ${removed} messages. ${keep} recent kept.`);
+    else this.print("Nothing to compact.");
+  }
+
+  // ------------------------------------------------------------------ model & provider commands
+
+  async cmdStatus() {
+    const ram = Platform.ramGB();
+    const tier = Platform.recommendTier();
+    const threads = Platform.recommendThreads();
+    const stats = this.agent.stats();
+    const model = this.cfg.activeModel();
+    const ogpt = this.cfg.displayName(model);
+    let loaded = "none";
+    try {
+      const running = await this.provider.runningModels();
+      if (running.length) loaded = running.map((m) => m.name).join(", ");
+    } catch {}
+    const keepAlive = this.cfg.get("ollama.keep_alive", "30m");
+    const numCtx = this.cfg.get("ollama.num_ctx", 8192);
+    this.print(`
+  Status:
+    Model:          ${ogpt} (${model})
+    Loaded:         ${loaded}
+    RAM:            ${ram}GB (tier: ${tier}, threads: ${threads})
+    Perf:           keep_alive=${keepAlive}, ctx=${numCtx}
+    Messages:       ${stats.messages}
+    Tokens:         ${stats.totalTokens}
+    Auto-approve:   ${this.tools._autoApprove ? "ON" : "OFF"}
+`);
+  }
+
+  switchModel(name) {
+    const resolved = this.cfg.resolveModel(name);
+    if (catalog.isOgptName(name) && !catalog.resolveModel(name)) {
+      this.error(`Unknown oGPT model: ${name}. See /catalog for valid names.`);
+      return;
+    }
+    this.cfg.set("active_model", resolved);
+    this.success(`Switched to model: ${this.cfg.displayName(resolved)} (${resolved})`);
+  }
+
+  async cmdModel(args) {
+    if (!args || !args.length) {
+      await this.cmdModels();
+      this.info("Switch with /model <oGPT-name> - e.g. /model oGPT-2a");
+      return;
+    }
+    this.switchModel(args[0]);
+  }
+
+  async cmdModels() {
+    const models = await this.provider.listModels(true);
+    if (!models.length) {
+      this.print("No models found. Pull one with: /pull <oGPT-name>");
+      return;
+    }
+    const rows = models.map((m) => [
+      m.id,
+      this.cfg.displayName(m.id),
+      m.size ? formatSize(m.size) : "-",
+      m.id === this.cfg.activeModel() ? "←" : "",
+    ]);
+    this._table("Installed Models", ["Model ID", "oGPT Name", "Size", ""], rows);
+  }
+
+  cmdCatalog() {
+    const rows = catalog.entries().map(([id, e]) => [
+      e.ogpt,
+      id,
+      e.provider || "local",
+      e.size || "-",
+      e.ram_gb ? `${e.ram_gb}GB` : "-",
+      e.desc,
+      id === this.cfg.activeModel() ? "←" : "",
+    ]);
+    this._table(
+      "oGPT Model Catalog",
+      ["oGPT", "Model ID", "Provider", "Size", "Min RAM", "Description", ""],
+      rows
+    );
+    this.info("Install with /pull <oGPT-name> · switch with /model <oGPT-name>");
+  }
+
+  async cmdPull(args) {
+    if (!args || !args.length) { this.error("Usage: /pull <oGPT-name|model-id>"); return; }
+    const model = this.cfg.resolveModel(args[0]);
+    let lastPct = -1;
+    for await (const prog of this.provider.pull(model)) {
+      if (prog.error) { this._raw("\n"); this.error(`Pull failed: ${prog.error}`); return; }
+      const total = prog.total || 0;
+      const done = prog.completed || 0;
+      if (total && done) {
+        const pct = Math.floor((done * 100) / total);
+        if (pct !== lastPct) {
+          const bar = "█".repeat(Math.floor(pct / 5)) + "░".repeat(20 - Math.floor(pct / 5));
+          this._raw(`\r  [pull ${model}] ${bar} ${pct}% (${(done / 1e6).toFixed(0)}/${(total / 1e6).toFixed(0)} MB)`);
+          lastPct = pct;
+        }
+      }
+    }
+    this._raw("\r" + " ".repeat(72) + "\r");
+    this.success(`Pulled ${model} (${this.cfg.displayName(model)})`);
+  }
+
+  async cmdPs() {
+    let models;
+    try {
+      models = await this.provider.runningModels();
+    } catch (e) {
+      this.error(`Local engine unavailable: ${e.message}`);
+      return;
+    }
+    if (!models.length) { this.print("No models loaded in memory."); return; }
+    const rows = models.map((m) => [
+      m.name || "?",
+      this.cfg.displayName(m.name || ""),
+      formatSize(m.size || 0),
+      m.expires_at ? new Date(m.expires_at).toLocaleTimeString() : "-",
+    ]);
+    this._table("Loaded Models", ["Model", "oGPT Name", "Size", "Expires"], rows);
+  }
+
+  async cmdWarmup(args) {
+    const model = args && args.length ? this.cfg.resolveModel(args[0]) : this.cfg.activeModel();
+    this.info(`Warming up ${this.cfg.displayName(model)}...`);
+    const t0 = Date.now();
+    const ok = await this.provider.warmup(model);
+    if (ok) this.success(`${this.cfg.displayName(model)} loaded in ${((Date.now() - t0) / 1000).toFixed(1)}s - first message will be instant`);
+    else this.error("Warmup failed - is the local engine running?");
+  }
+
+  // ------------------------------------------------------------------ session commands
+
+  cmdSave() {
+    const sid = this.saveSession();
+    if (sid) this.success(`Saved session: ${sid}`);
+    else this.warn("Session persistence not configured in this build.");
+  }
+
+  cmdNew(args) {
+    // Archive the current chat and start a completely fresh one.
+    const title = (args || []).join(" ").trim();
+    const had = this.agent.history.some((m) => String(m.content || "").trim());
+    if (had && this.cfg.get("session.auto_save", true)) {
+      const sid = this.saveSession();
+      if (sid) this.success(`Archived chat as session ${sid}`);
+    } else if (had) {
+      this.warn("Previous chat discarded (auto-save is off)");
+    }
+    this.agent.clear();
+    this._sessionId = Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+    this.success(`New chat ready - session ${this._sessionId}${title ? ` "${title}"` : ""}`);
+  }
+
+  cmdReset() {
+    this.agent.clear();
+    try { this.cmdMemory(["clear"]); } catch {}
+    this._sessionId = null;
+    this.success("Everything reset.");
+  }
+
+  cmdProvider(args) {
+    if (!args || !args.length) {
+      this._table("Providers", ["Name", "Status", "Models"], [
+        ["Ollama", "Available", "local"],
+      ]);
+      return;
+    }
+    const name = args[0].toLowerCase();
+    if (name === "ollama") this.success("Already using Ollama.");
+    else this.error(`Unknown provider '${args[0]}' - this build runs on Ollama only.`);
+  }
+
+  cmdContext(args) {
+    const n = args && /^\d+$/.test(args[0]) ? parseInt(args[0], 10) : 20;
+    const msgs = this.agent.history.filter((m) => m.role !== "tool");
+    if (!msgs.length) { this.info("No conversation history."); return; }
+    for (const m of msgs.slice(-n)) {
+      const who = m.role === "user" ? "you" : m.role === "assistant" ? this.cfg.displayName() : m.role;
+      this.printColor(m.role === "user" ? "cyan" : "magenta", `\n${who}:`);
+      this.print(String(m.content || "").slice(0, 2000));
+    }
+  }
+
+  cmdIndex() {
+    const lines = [];
+    const IGNORE = new Set(["node_modules", ".git", "__pycache__", ".venv", "venv", ".ogpt"]);
+    const walk = (dir, prefix, depth) => {
+      if (depth > 3 || lines.length > 220) return;
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true })
+          .filter((e) => !IGNORE.has(e.name) && !e.name.startsWith("."));
+      } catch { return; }
+        entries.sort((a, b) => (b.isDirectory() - a.isDirectory()) || a.name.localeCompare(b.name));
+      entries.slice(0, 40).forEach((e, i) => {
+        const last = i === Math.min(entries.length, 40) - 1;
+        lines.push(`${prefix}${last ? "`-- " : "|-- "}${e.name}${e.isDirectory() ? "/" : ""}`);
+        if (e.isDirectory()) walk(path.join(dir, e.name), prefix + (last ? "    " : "|   "), depth + 1);
+      });
+    };
+    lines.push(`${path.basename(process.cwd())}/`);
+    walk(process.cwd(), "", 0);
+    this.print(`## Project Structure\n\`\`\`\n${lines.join("\n")}\n\`\`\``);
+  }
+
+  cmdSession(args) {
+    const sub = (args && args[0]) || "list";
+    if (sub === "list") return this.cmdSessions();
+    if (sub === "save") return this.cmdSave();
+    if (sub === "new" || sub === "fresh") return this.cmdNew(args.slice(1));
+    if (sub === "load") return args[1] ? this.cmdLoad([args[1]]) : this.error("Usage: /session load <id>");
+    if (sub === "delete") {
+      if (!args[1]) return this.error("Usage: /session delete <id>");
+      try {
+        const dir = this._sessionsDir();
+        fs.unlinkSync(path.join(dir, `${args[1]}.json`));
+        try { fs.unlinkSync(path.join(dir, `${args[1]}.meta.json`)); } catch {}
+        this.success(`Deleted session: ${args[1]}`);
+      } catch { this.error(`Session not found: ${args[1]}`); }
+      return;
+    }
+    this.error("Usage: /session new|save|list|load|delete <id>");
+  }
+
+  saveSession() {
+    // Sessions use the SAME on-disk format as the Python build so both
+    // versions share one history: <id>.json holds the message array and
+    // <id>.meta.json holds { id, title, created, updated, msgs }.
+    try {
+      const dir = this._sessionsDir();
+      if (!this._sessionId) this._sessionId = this._newSessionId();
+      const data = this.agent.history.map((m) => ({ role: m.role, content: m.content }));
+      fs.writeFileSync(path.join(dir, `${this._sessionId}.json`),
+        JSON.stringify(data, null, 2));
+      let meta = {};
+      const metaPath = path.join(dir, `${this._sessionId}.meta.json`);
+      try { meta = JSON.parse(fs.readFileSync(metaPath, "utf-8")); } catch {}
+      if (!meta.id) {
+        meta = { id: this._sessionId,
+          title: `Session ${new Date().toISOString().slice(0, 16).replace("T", " ")}`,
+          created: Date.now() / 1000, ...meta };
+      }
+      meta.updated = Date.now() / 1000;
+      meta.msgs = data.length;
+      fs.writeFileSync(metaPath, JSON.stringify(meta));
+      return this._sessionId;
+    } catch {
+      return null;
+    }
+  }
+
+  _sessionsDir() {
+    const dir = path.join(os.homedir(), ".config", "ogpt", "sessions");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  _newSessionId() {
+    return require("crypto").randomBytes(6).toString("hex").replace(/^(.{4})/, "$1-");
+  }
+
+  loadSession(sid) {
+    const p = path.join(this._sessionsDir(), `${sid}.json`);
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    this.agent.history = (Array.isArray(data) ? data : []).map((d) => ({
+      role: d.role || "user", content: d.content || "", ts: Date.now() / 1000 }));
+    this._sessionId = sid;
+    return this.agent.history.length;
+  }
+
+  cmdLoad(args) {
+    if (!args || !args.length) { this.error("Usage: /load <session-id>"); return; }
+    try {
+      const n = this.loadSession(args[0]);
+      this.success(`Loaded session: ${args[0]} (${n} messages)`);
+    } catch {
+      this.error(`Session not found: ${args[0]} (see /sessions)`);
+    }
+  }
+
+  cmdSessions() {
+    let rows = [];
+    try {
+      const dir = this._sessionsDir();
+      rows = fs.readdirSync(dir).filter((f) => f.endsWith(".meta.json"))
+        .map((f) => {
+          try { return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8")); }
+          catch { return null; }
+        })
+        .filter(Boolean)
+        .sort((a, b) => (b.updated || 0) - (a.updated || 0))
+        .map((m) => [m.id || "?", m.title || "", String(m.msgs ?? 0),
+                     new Date((m.updated || 0) * 1000).toLocaleString()]);
+    } catch {}
+    if (!rows.length) { this.print("No sessions found."); return; }
+    this._table("Sessions", ["ID", "Title", "Messages", "Updated"], rows);
+  }
+
+  // ------------------------------------------------------------------ tools commands
+
+  cmdTools() {
+    const rows = this.tools.listTools().map((t) => [
+      t.name,
+      t.description,
+      t.dangerous ? "⚠" : "",
+    ]);
+    this._table("Available Tools", ["Name", "Description", "Risky"], rows);
+  }
+
+  // ------------------------------------------------------------------ memory & tasks
+
+  cmdMemory(args) {
+    const sub = args && args.length ? args[0] : "";
+    if (!sub) {
+      this.print("Memory is stored per-project. Use /memory add <text> or /memory search <query>.");
+      return;
+    }
+    if (sub === "add") {
+      const text = args.slice(1).join(" ").trim();
+      if (!text) { this.error("Usage: /memory add <text>"); return; }
+      this.memoryAdd(text);
+      this.success(`Added note: ${text}`);
+      return;
+    }
+    if (sub === "search") {
+      const q = args.slice(1).join(" ").trim();
+      const results = this.memorySearch(q);
+      if (results.length) results.forEach((r) => this.print(`  ${r}`));
+      else this.print(`No results for: ${q}`);
+      return;
+    }
+    if (sub === "clear") {
+      this.memoryClear();
+      this.success("Memory cleared.");
+      return;
+    }
+    this.error(`Unknown memory command: ${sub}`);
+  }
+
+  memoryFile() {
+    const path = require("path");
+    const os = require("os");
+    return path.join(process.cwd(), ".ogpt-memory.json");
+  }
+
+  memoryRead() {
+    try { return JSON.parse(require("fs").readFileSync(this.memoryFile(), "utf-8")); } catch { return []; }
+  }
+
+  memoryAdd(text) {
+    const notes = this.memoryRead();
+    notes.push({ text, ts: Date.now() });
+    require("fs").writeFileSync(this.memoryFile(), JSON.stringify(notes, null, 2));
+  }
+
+  memorySearch(q) {
+    return this.memoryRead()
+      .filter((n) => n.text.toLowerCase().includes(q.toLowerCase()))
+      .map((n) => `${new Date(n.ts).toLocaleString()}: ${n.text}`);
+  }
+
+  memoryClear() {
+    try { require("fs").unlinkSync(this.memoryFile()); } catch {}
+  }
+
+  cmdTask(args) {
+    const sub = args && args.length ? args[0] : "list";
+    if (sub === "list") {
+      const tasks = this.tasksRead();
+      if (!tasks.length) { this.print("No tasks."); return; }
+      this._table("Tasks", ["ID", "Description", "Status"], tasks.map((t) => [t.id, t.description, t.status]));
+      return;
+    }
+    if (sub === "new") {
+      const desc = args.slice(1).join(" ").trim();
+      if (!desc) { this.error("Usage: /task new <description>"); return; }
+      const tasks = this.tasksRead();
+      const task = { id: String(tasks.length + 1).padStart(3, "0"), description: desc, status: "pending", ts: Date.now() };
+      tasks.push(task);
+      this.tasksWrite(tasks);
+      this.success(`Created task: ${task.id}`);
+      return;
+    }
+    if (sub === "update") {
+      if (args.length < 3) { this.error("Usage: /task update <id> <status>"); return; }
+      const tasks = this.tasksRead();
+      const t = tasks.find((x) => x.id === args[1]);
+      if (!t) { this.error(`Task not found: ${args[1]}`); return; }
+      t.status = args[2];
+      this.tasksWrite(tasks);
+      this.success(`Updated task: ${t.id}`);
+      return;
+    }
+    this.error(`Unknown task command: ${sub}`);
+  }
+
+  tasksFile() { return require("path").join(process.cwd(), ".ogpt-tasks.json"); }
+  tasksRead() { try { return JSON.parse(require("fs").readFileSync(this.tasksFile(), "utf-8")); } catch { return []; } }
+  tasksWrite(tasks) { require("fs").writeFileSync(this.tasksFile(), JSON.stringify(tasks, null, 2)); }
+
+  // ------------------------------------------------------------------ system commands
+
+  cmdConfig() {
+    const scrub = (obj) => {
+      if (Array.isArray(obj)) return obj.map(scrub);
+      if (obj && typeof obj === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+          out[k === "ollama" ? "local" : k] = scrub(v);
+        }
+        return out;
+      }
+      if (typeof obj === "string") return obj.replace(/ollama/g, "local").replace(/Ollama/g, "Local");
+      return obj;
+    };
+    const safe = JSON.parse(JSON.stringify(this.cfg.data()));
+    for (const p of Object.values(safe.providers || {})) delete p.api_key;
+    this.print(JSON.stringify(scrub(safe), null, 2));
+  }
+
+  cmdTier() {
+    const routing = this.cfg.get("model_routing", {});
+    this.print(`
+  Recommended tier: ${Platform.recommendTier()}
+  RAM: ${Platform.ramGB()}GB
+  Models:
+    fast:     ${routing.fast || "qwen2.5-coder:1.5b"} (${catalog.displayName(routing.fast || "qwen2.5-coder:1.5b")})
+    balanced: ${routing.balanced || "qwen2.5-coder:7b"} (${catalog.displayName(routing.balanced || "qwen2.5-coder:7b")})
+    pro:      ${routing.pro || "qwen2.5-coder:32b"} (${catalog.displayName(routing.pro || "qwen2.5-coder:32b")})
+`);
+  }
+
+  cmdStats() {
+    const s = this.agent.stats();
+    this.print(`
+  Stats:
+    Messages:     ${s.messages}
+    Total tokens: ${s.totalTokens}
+    Prompt:       ${s.promptTokens}
+    Completion:   ${s.completionTokens}
+`);
+  }
+
+  // ------------------------------------------------------------------ settings commands
+
+  cmdToggle(key, label) {
+    const current = this.cfg.get(key, true);
+    this.cfg.set(key, !current);
+    this.success(`${label}: ${!current ? "ON" : "OFF"}`);
+  }
+
+  cmdAlias(args) {
+    const aliases = this.cfg.get("aliases", {}) || {};
+    if (!args || !args.length) {
+      const names = Object.keys(aliases);
+      if (!names.length) { this.info("No aliases. Create one: /alias big /model oGPT-3a"); return; }
+      for (const name of names.sort()) this.print(`  ${name} → ${aliases[name]}`);
+      return;
+    }
+    if (args[0] === "remove" && args.length > 1) {
+      const name = args[1].toLowerCase();
+      if (name in aliases) {
+        delete aliases[name];
+        this.cfg.set("aliases", aliases);
+        this.success(`Removed alias: ${name}`);
+      } else this.error(`No such alias: ${name}`);
+      return;
+    }
+    if (args.length < 2) { this.error("Usage: /alias <name> </command>"); return; }
+    const name = args[0].toLowerCase();
+    const target = args.slice(1).join(" ");
+    if (!target.startsWith("/")) { this.error("Alias target must be a command starting with /"); return; }
+    aliases[name] = target;
+    this.cfg.set("aliases", aliases);
+    this.success(`Alias created: ${name} → ${target}`);
+  }
+
+  // ------------------------------------------------------------------ review (git diff prompt)
+
+  async cmdReview() {
+    const { execSync } = require("child_process");
+    let diff = "";
+    try {
+      diff = execSync("git diff HEAD", { encoding: "utf-8", timeout: 10000, maxBuffer: 1024 * 1024 * 4 });
+    } catch (e) {
+      this.error(`git diff failed: ${e.message.split("\n")[0]}`);
+      return;
+    }
+    if (!diff.trim()) { this.print("No uncommitted changes found."); return; }
+    await this._chat(
+      "Review the following uncommitted changes. Comment on correctness, bugs, security issues, and style. Be specific and concise.\n\n```diff\n" +
+        diff.slice(0, 8000) +
+        "\n```"
+    );
+  }
+
+  // ------------------------------------------------------------------ local engine bootstrap
+
+  async ensureOllama() {
+    const available = await this.provider.isAvailable();
+    if (!available) {
+      this.warn("Local engine not found or not running.");
+      this.printColor("dim", "Please install the local engine, then start it and try again.");
+      return false;
+    }
+
+    const ram = Platform.ramGB();
+    const tier = Platform.recommendTier();
+    const currentModel = this.cfg.activeModel();
+
+    const { recommendForRam } = catalog;
+    const fit = recommendForRam(ram);
+    const installed = new Set((await this.provider.listModels(true)).map((m) => m.id));
+
+    let target;
+    if (installed.has(currentModel)) target = currentModel;
+    else if (fit && !installed.has(fit)) target = fit; // worth downloading: matches RAM
+    else target = await this.provider.bestAvailableModel(tier, currentModel);
+
+    if (target !== currentModel) {
+      this.cfg.set("active_model", target);
+      this.printColor("cyan", `Auto-selected model: ${this.cfg.displayName(target)} (tier: ${tier}, RAM: ${ram}GB)`);
+    }
+
+    if (!installed.has(target)) {
+      this.info(`Pulling ${this.cfg.displayName(target)} (${target})...`);
+      try {
+        await this.cmdPull([target]);
+      } catch {
+        this.warn(`Failed to pull ${target}.`);
+        return true;
+      }
+    }
+
+    // Warm up in the background so the first message is instant
+    if (this.cfg.get("ollama.warmup", true)) this.startWarmup(target);
+    return true;
+  }
+
+  startWarmup(model) {
+    if (this._warmupBusy) return;
+    this._warmupBusy = true;
+    const ogptName = this.cfg.displayName(model);
+    const t0 = Date.now();
+    if (!this._chatActive && !this._replStarted) this.info(`[warmup] preloading ${ogptName}...`);
+    this.provider
+      .warmup(model)
+      .then((ok) => {
+        if (this._chatActive || this._replStarted) return; // never print over chat or prompt
+        if (ok) this.success(`[warmup] ${ogptName} ready in ${((Date.now() - t0) / 1000).toFixed(1)}s`);
+        else this.warn("[warmup] skipped (server busy or unreachable)");
+      })
+      .catch(() => {})
+      .finally(() => { this._warmupBusy = false; });
+  }
+
+  // ------------------------------------------------------------------ main loops
+
+  async runInteractive() {
+    this.splash();
+    await this.ensureOllama();
+
+    const dashUrl = await web.startDashboard(this).catch(() => null);
+    if (dashUrl) this.printColor("dim", `Token dashboard: ${dashUrl}  (/dash to reopen)`);
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: process.stdin.isTTY === true,
+      historySize: 1000,
+    });
+
+    // Route tool-permission questions through this readline loop: pause the
+    // main prompt while asking, so answers can never be swallowed by the
+    // idle input reader (that was mangling y/n into bogus denials).
+    this.tools._perm.ui_hook = (toolName, desc) => new Promise((resolve) => {
+      rl.pause();
+      process.stdout.write(`\n\x1b[33m  Permission:\x1b[0m ${toolName} -> ${String(desc).slice(0, 80)}\n`);
+      const q = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+      q.question("  Allow? (y/n/a=always): ", (ans) => {
+        try { q.close(); } catch {}
+        resolve(String(ans || "").trim().toLowerCase());
+      });
+      q.on("close", () => { try { rl.resume(); } catch {} });
+    });
+
+    const ask = () =>
+      new Promise((resolve) => {
+        if (!this.running) return resolve(undefined);
+        this._replStarted = true;
+        rl.question(this.prompt(), (ans) => resolve(ans));
+      });
+
+    while (this.running) {
+      let answer;
+      try {
+        answer = await ask();
+      } catch {
+        break;
+      }
+      if (answer === undefined) break;
+      const input = answer.trim();
+      if (!input) continue;
+
+      if (await this.processCommand(input)) continue;
+      await this._chat(input);
+    }
+
+    rl.close();
+    this.provider.close();
+  }
+
+  async runSingle(promptText) {
+    await this.ensureOllama();
+    await this._chat(promptText);
+    this.provider.close();
+  }
+}
+
+// ANSI helpers used in help rendering
+function D() { return process.stdout.isTTY ? "\x1b[2m" : ""; }
+function R() { return process.stdout.isTTY ? "\x1b[0m" : ""; }
+
+function formatSize(bytes) {
+  if (bytes >= 1e9) return (bytes / 1e9).toFixed(1) + " GB";
+  if (bytes >= 1e6) return (bytes / 1e6).toFixed(0) + " MB";
+  if (bytes >= 1e3) return (bytes / 1e3).toFixed(0) + " KB";
+  return bytes + " B";
+}
+
+module.exports = { CLI };