@tiens.nguyen/gu-cli 1.0.738 → 1.0.740

package/gonext_agent_chat.py

@@ -4764,6 +4764,9 @@ _RAG_SKIP_DIRS = {
     # .github, .vscode or .claude — those carry CI config, editor settings and project
     # instructions a coding agent legitimately benefits from reading.
     ".claude-memory", ".specstory", ".aider.tags.cache.v3", ".goose",
+    # gu's OWN memory store (the memory skill's .gu-memory/, task #269): the agent reaches it
+    # through the memory MCP tools, which query it — not by grepping raw checkpoint markdown.
+    ".gu-memory",
 }
 # Machine-generated files that are TEXT but never worth reading. A lockfile is the whole
 # problem in miniature: in the reported Next.js project package-lock.json is 239KB while every
@@ -6695,6 +6698,9 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline
         _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
     elif command.startswith("__S3SETUP__::"):
         _emit({"type": "step", "text": "Awaiting your choice: set up S3, or save on this computer?"})
+    elif command.startswith("__MCPTOOL__::"):
+        _srv, _, _rest = command[len("__MCPTOOL__::"):].partition("\t")
+        _emit({"type": "step", "text": f"Awaiting your approval: MCP tool {_srv}/{_rest.split(chr(9))[0]}"})
     else:
         _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
     deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
@@ -7073,6 +7079,12 @@ def run_agent_chat(cfg):
     # risky command and asks the user via the API instead of hard-blocking it.
     _job_id = (cfg.get("jobId") or "").strip()
     _interactive_approval = bool(cfg.get("interactiveApproval"))
+    # Skills and MCP servers (task #269). The worker scans ~/.gonext/skills, ~/.gonext/mcp.json and
+    # this folder's .gonext/skills + .mcp.json for every turn; none present = neither appears
+    # anywhere in the prompt. Names only here — a skill's body is read when it is used.
+    import gu_skills as _skills_mod
+    _skills = _skills_mod.clean_list(cfg.get("skills"))
+    _mcp_cfg = cfg.get("mcp") if isinstance(cfg.get("mcp"), dict) else {}
 
     def _ask_s3_setup() -> bool:
         """Private mode, a file to hand over, no S3 of the user's own (task #252): ask in the
@@ -7230,6 +7242,14 @@ def run_agent_chat(cfg):
     # below. Otherwise the keyword router matches URLs/"api"/"GET" from prior turns
     # and fires the agent on trivial replies like "thanks" or "good".
     latest_user_text = task_text
+    # `/<skill> request` typed in the terminal (task #269): the skill's instructions go in with
+    # the request, for this turn only — the history keeps the short line the user typed.
+    _skill_call = _skills_mod.invocation(task_text, _skills)
+    if _skill_call:
+        _sk, _sk_body, _sk_req = _skill_call
+        task_text = (_skills_mod.render(_sk, _sk_body) + "\n\nThe user's request: "
+                     + (_sk_req or "(nothing more — do what the skill describes)"))
+        _log(f"skill invoked: {_sk['name']}")
 
     # Walk prior turns newest-first, keeping condensed lines until the budget is
     # spent, then restore chronological (oldest→newest) order.
@@ -7862,6 +7882,11 @@ def run_agent_chat(cfg):
         needs_agent = True
     else:
         needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
+    # A skill the user typed is work to DO with tools — plain chat cannot follow one.
+    if not needs_agent and _skill_call:
+        _log("router → YES (skill invoked)")
+        _emit({"type": "step", "text": "→ Agent mode (skill)"})
+        needs_agent = True
     # A pending email awaiting 'confirm' must reach the agent even though a bare
     # 'confirm' / 'send it' is not a network keyword — otherwise the send never fires.
     if not needs_agent and _email_confirm_pending():
@@ -8270,6 +8295,7 @@ def run_agent_chat(cfg):
         "When you have enough to answer, call final_answer(<your answer>) in a code block. "
         "Prefer FEWER steps, and never repeat a tool call that already succeeded.\n\n"
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
+        + _skills_mod.prompt_block(_skills)
         + _rag_tool_block + _ws_tool_block + _auto_test_block +
         "\n"
         "http_request RETURN FORMAT: 'HTTP 200\\n{body}' — first line is 'HTTP <code>', body follows.\n"
@@ -12405,6 +12431,62 @@ def run_agent_chat(cfg):
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
                 agent_tools += [list_dir, read_text_file]
+        # SKILLS (task #269): only offered when at least one exists, like every tool above.
+        if _skills:
+            @tool
+            def use_skill(name: str) -> str:
+                """Load a skill's full instructions by its name from the SKILLS list. Call it FIRST when the task matches a skill, then follow what it returns.
+
+                Args:
+                    name: the skill's name, exactly as listed under SKILLS
+                """
+                return _skills_mod.use_skill_text(_skills, name)
+
+            agent_tools.append(use_skill)
+        # MCP SERVERS (task #269): every tool of every server that starts, named
+        # mcp__<server>__<tool>. A server that does not start is a note for this turn, not a
+        # failure of it. Each call passes _mcp_approve first. Not for the between-turns index job,
+        # which calls no model and would start the servers for nothing.
+        _mcp_servers = [s for s in (_mcp_cfg.get("servers") or [])
+                        if isinstance(s, dict) and s.get("name") and s.get("command")]
+        if _mcp_servers and not cfg.get("ragIndexOnly"):
+            import atexit as _atexit
+            import gu_mcp as _mcp_mod
+            from smolagents import Tool as _SmolTool
+            _mcp_turn_allowed: set = set()
+
+            def _mcp_approve(server: str, tool_name: str, args: dict):
+                """deny → allow → ask (Claude Code's order). The rules are re-read from the file on
+                every call: an "Always allow" answered a moment ago was written there."""
+                allow, deny = _mcp_mod.read_rules(_mcp_cfg.get("configPath"),
+                                                  _mcp_cfg.get("allow") or [], _mcp_cfg.get("deny") or [])
+                verdict = _mcp_mod.decide(allow, deny, server, tool_name)
+                if verdict == "deny":
+                    return False, (f"MCP tool {server}/{tool_name} is blocked by a deny rule in "
+                                   "~/.gonext/mcp.json. Do not call it again; carry on without it.")
+                if verdict == "allow" or (server, tool_name) in _mcp_turn_allowed:
+                    return True, ""
+                if not (_interactive_approval and _job_id and worker_api_base and worker_api_key):
+                    return False, (f"MCP tool {server}/{tool_name} needs the user's approval and this "
+                                   "session cannot ask. Tell the user to allow it in the gu terminal "
+                                   f"(/mcp allow {server}), then carry on without it.")
+                preview = json.dumps(args, ensure_ascii=False, default=str)
+                if len(preview) > 240:
+                    preview = preview[:240] + "…"
+                ok = _ws_request_approval(worker_api_base, worker_api_key, _job_id,
+                                          f"__MCPTOOL__::{server}\t{tool_name}\t{preview}", "")
+                if ok:
+                    _mcp_turn_allowed.add((server, tool_name))
+                    return True, ""
+                return False, (f"The user declined MCP tool {server}/{tool_name}. Do not call it again "
+                               "this turn; carry on without it or ask the user.")
+
+            _emit({"type": "step", "text": f"Starting {len(_mcp_servers)} MCP server(s)…"})
+            _mcp_conn, _mcp_notes = _mcp_mod.connect_all(_mcp_servers, _WS_ACTIVE or None, log=_log)
+            _atexit.register(lambda: [c.close() for c, _t in _mcp_conn])
+            for _note in _mcp_notes:
+                _emit({"type": "step", "text": _note})
+            agent_tools += _mcp_mod.build_tools(_mcp_conn, _SmolTool, _mcp_approve)
         # Fill in the numbered tool list now that the REAL tool objects exist — see
         # _render_numbered_tool_list and the {{TOOL_LIST}} placeholder left in tool_hint.
         task_with_hint = task_with_hint.replace(

package/gu-cli.mjs

@@ -33,6 +33,27 @@ import { createRequire } from "node:module";
 import dotenv from "dotenv";
 import OpenAI from "openai";
 import { resolvePython } from "./platform-tools.mjs";
+import { skillsForTurn } from "./skills.mjs";
+import { mcpForTurn } from "./mcp-config.mjs";
+
+/** The `skills` / `mcp` fields of one job's agent config (task #269). A broken config is a log
+ *  line, never a failed turn — the turn runs without them. */
+function skillsAndMcpForJob(cwd) {
+  const out = {};
+  try {
+    const skills = skillsForTurn({ cwd });
+    if (skills.length) out.skills = skills;
+  } catch (e) {
+    console.log(`[gu-worker] skills skipped: ${e?.message || e}`);
+  }
+  try {
+    const mcp = mcpForTurn({ cwd });
+    if (mcp.servers.length) out.mcp = mcp;
+  } catch (e) {
+    console.log(`[gu-worker] MCP servers skipped: ${e?.message || e}`);
+  }
+  return out;
+}
 
 const WORKER_DIR = dirname(fileURLToPath(import.meta.url));
 
@@ -223,6 +244,16 @@ if (args[0] === "token") {
   process.exit(0);
 }
 
+if (args[0] === "mcp") {
+  // #269. MCP servers from a shell — `claude mcp add`'s shape. Same code as /mcp in the terminal UI.
+  const { runMcpCommand } = await import("./mcp-command.mjs");
+  const code = await runMcpCommand(args.slice(1), {
+    cwd: process.cwd(),
+    print: (line, kind) => (kind === "warn" ? console.error(line) : console.log(line)),
+  });
+  process.exit(code);
+}
+
 if (args[0] === "full-log") {
   // #250. An administrator switches Enable Full Log (#249) from a terminal — after typing an admin
   // token minted on the web admin page. Same code as /full-log in the terminal UI.
@@ -3836,6 +3867,10 @@ async function runAgentChatJob(job) {
       // Task #134: set when the terminal's folder is on ANOTHER machine. The agent surfaces
       // it to the user — a silent downgrade to "no file tools" would just look broken.
       ...(remoteWorkspace ? { remoteWorkspace } : {}),
+      // Skills and MCP servers (task #269), read from disk for EVERY job so an edited, added or
+      // deleted SKILL.md / server takes effect on the next turn with no restart. The project's
+      // own ones only when its folder is on this machine. None = the keys are absent.
+      ...skillsAndMcpForJob(terminalActiveWs && wsExistsHere ? terminalActiveWs : null),
     });
     // Agent run time budget (task #81). Default 60 min; user-configurable in web Settings
     // (agentTimeoutMinutes → payload.agentTimeoutMs). Multi-step ReAct on a 14B/31B with a

package/gu-repl.mjs

@@ -119,6 +119,9 @@ import {
   shouldCancelPrompt,
 } from "./terminal-layout.mjs";
 import { completedFlush } from "./completed-flush.mjs";
+import { discoverSkills, matchSkillCommand } from "./skills.mjs";
+import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
+import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
 import {
@@ -532,7 +535,7 @@ const argv = process.argv.slice(2);
 // process.argv and exits inside its own subcommand branch, before it ever starts polling.
 const CLI_SUBCOMMANDS = [
   "status", "start", "stop", "restart", "logs", "doctor", "login", "set", "rag",
-  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log",
+  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log", "mcp",
 ];
 // `gu logz` USED TO START THE REPL (task #181). Silently: an unrecognised word was not in
 // the list, so it fell through to "no subcommand given" and a full agent session opened in that
@@ -807,6 +810,7 @@ const COMMANDS = [
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
   { name: "/full-log", usage: "/full-log [on|off|status] [account]", desc: "administrators: Enable Full Log for an account — asks for an admin token from the web admin page first" },
+  { name: "/mcp", usage: "/mcp [list|tools|add|remove|enable|disable|approve|allow|disallow|reconnect]", desc: "MCP servers: see which connect, add one (asks step by step), choose which tools run without asking" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -814,22 +818,50 @@ const COMMANDS = [
 // terminal-layout.mjs — their handlers are below, above the unknown-command guard. Not
 // imported here: nothing in the REPL reads the list, the tests do (task #153).
 const COMMAND_NAMES = COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]);
+// SKILLS ARE COMMANDS TOO (task #269): each ~/.gonext/skills/<name>/SKILL.md (and this folder's
+// .gonext/skills) is /<name>, in Tab-completion and /help like any other. Scanned from disk — kept
+// for 2s only, because the overlay asks on every keystroke — so a skill added, edited or DELETED
+// while gu runs shows up (or quietly disappears) without a restart. A built-in name always wins.
+let _skillScan = { at: 0, skills: [] };
+function currentSkills() {
+  if (Date.now() - _skillScan.at > 2000) {
+    try {
+      _skillScan = { at: Date.now(), skills: discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES }).skills };
+    } catch {
+      _skillScan = { at: Date.now(), skills: [] };
+    }
+  }
+  return _skillScan.skills;
+}
+const skillCommands = () =>
+  currentSkills()
+    .filter((s) => s.slash)
+    .map((s) => ({ name: `/${s.name}`, usage: `/${s.name} [request]`, desc: `skill — ${firstSentence(s.description)}`, skill: true }));
+/** A skill's description is written for the MODEL and often runs a paragraph; /help shows one line. */
+function firstSentence(text, max = 100) {
+  const one = String(text ?? "").split(/(?<=[.!?])\s/)[0].trim();
+  return one.length > max ? one.slice(0, max - 1).trimEnd() + "…" : one;
+}
+const allCommands = () => [...COMMANDS, ...skillCommands()];
+const allCommandNames = () => [...COMMAND_NAMES, ...skillCommands().map((c) => c.name)];
 // Tab-completion: when the line starts with "/", complete against the command names.
 function slashCompleter(line) {
   if (!line.startsWith("/")) return [[], line];
-  const hits = COMMAND_NAMES.filter((n) => n.startsWith(line));
-  return [hits.length ? hits : COMMAND_NAMES, line];
+  const names = allCommandNames();
+  const hits = names.filter((n) => n.startsWith(line));
+  return [hits.length ? hits : names, line];
 }
 // Commands whose name/alias matches the typed prefix (all when prefix is "" or "/").
 function filteredCommands(prefix = "") {
   const p = (prefix ?? "").trim();
-  const m = COMMANDS.filter(
+  const cmds = allCommands();
+  const m = cmds.filter(
     (c) =>
       !p ||
       p === "/" ||
       [c.name, ...(c.aliases ?? [])].some((n) => n.startsWith(p))
   );
-  return m.length ? m : COMMANDS;
+  return m.length ? m : cmds;
 }
 // Display rows for a filtered command set; row `sel` (if >=0) is highlighted (❯ + bold).
 function hintRows(cmds, sel) {
@@ -7185,6 +7217,21 @@ async function runFullLogCommand(line) {
   console.log("");
 }
 
+/**
+ * /mcp (#269) — the same code as `gu mcp`. `/mcp add` alone asks step by step; its questions go
+ * through ask(), whose label is drawn in the frozen row (a readline prompt alone is invisible there).
+ */
+async function runMcpSlashCommand(line) {
+  const { runMcpCommand, splitWords } = await import("./mcp-command.mjs");
+  const style = { ok: accent, warn: yellow, dim };
+  await runMcpCommand(splitWords(line).slice(1), {
+    cwd: process.cwd(),
+    ask: (label) => ask(label + " "),
+    print: (l, kind) => console.log(GUTTER + (style[kind] ?? ((x) => x))(l)),
+  });
+  console.log("");
+}
+
 async function runProxyCommand(line) {
   const cmd = await import("./proxy-command.mjs");
   const store = await import("./proxy-store.mjs");
@@ -8250,6 +8297,10 @@ const COMPACT_PREFIX = "__COMPACT__::";
 // Private mode, a file to hand over, and no S3 of the user's own (task #252): set it up now, or
 // save the file on this computer. Allow = S3 is now set up AND passed its test.
 const S3SETUP_PREFIX = "__S3SETUP__::";
+// An MCP tool about to run for the first time (task #269): "<server>\t<tool>\t<args preview>".
+// "Always" writes an allow rule to ~/.gonext/mcp.json — the agent re-reads that file before every
+// call, so it counts from the next call of this same turn, and for every turn after.
+const MCPTOOL_PREFIX = "__MCPTOOL__::";
 async function approvalPrompt(command) {
   // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
   // redrawing it (the tick early-returns while a picker is active) — otherwise the block
@@ -8307,6 +8358,29 @@ async function approvalPrompt(command) {
     );
     return { allow: idx === 0, dontAsk: false };
   }
+  if (command.startsWith(MCPTOOL_PREFIX)) {
+    const [server = "", tool = "", preview = ""] = command.slice(MCPTOOL_PREFIX.length).split("\t");
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write(
+      "\n" + yellow(`⚙ Allow the MCP tool ${server}/${tool}?`) + dim("  (no answer in ~3 min = No)") + "\n" +
+        (preview ? dim("  " + preview) + "\n" : "")
+    );
+    const idx = await pickFromList(
+      ["Yes", `Yes, and always allow ${server}/${tool}`, `Yes, and always allow every ${server} tool`, "No"],
+      0,
+      { timeoutMs: 170000, timeoutIndex: 3 }
+    );
+    if (idx === 1 || idx === 2) {
+      const rule = idx === 1 ? `mcp__${server}__${tool}` : `mcp__${server}__*`;
+      try {
+        addAllowRule({ rule });
+        process.stdout.write(dim(`  (won't ask again: ${rule} — undo with /mcp disallow ${server})\n`));
+      } catch (e) {
+        process.stdout.write(yellow(`  could not save that (${e?.message || e}) — allowed this once\n`));
+      }
+    }
+    return { allow: idx >= 0 && idx <= 2, dontAsk: false };
+  }
   const isMax = command.startsWith(MAXSTEP_PREFIX);
   if (isMax) {
     const label = command.slice(MAXSTEP_PREFIX.length);
@@ -10665,8 +10739,33 @@ async function main() {
         const plan = acct.plan ? (acct.pro ? accent(acct.plan) : dim(acct.plan)) : "";
         statusRows.push(acct.email ? dim(`account ${acct.email}`) + (plan ? dim(" · ") + plan : "") : dim("plan ") + plan);
       }
+      // Skills and MCP servers (task #269) — one row, only when there are any.
+      try {
+        const nSkills = currentSkills().length;
+        const nMcp = listMcpServers({ cwd: process.cwd() }).servers.filter((x) => x.runnable).length;
+        const bits = [nSkills ? `${nSkills} skill${nSkills === 1 ? "" : "s"}` : "", nMcp ? `${nMcp} MCP server${nMcp === 1 ? "" : "s"}` : ""].filter(Boolean);
+        if (bits.length) statusRows.push(dim(bits.join(" · ") + "  (/help · /mcp)"));
+      } catch {
+        /* a broken file is reported below; the banner is not the place to fail */
+      }
       console.log(renderBanner(statusRows));
     }
+    // Skills and MCP (task #269): say what is BROKEN or WAITING, and nothing when all is well. A
+    // deleted skill is not broken — it is simply gone, and says nothing.
+    try {
+      for (const w of discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES }).warnings) {
+        console.log(GUTTER + yellow(w));
+      }
+      const waiting = unapprovedProjectServers(process.cwd());
+      if (waiting.length) {
+        console.log(
+          GUTTER + yellow(`This folder's .mcp.json names ${waiting.length} MCP server(s) that will not start until you approve them: ${waiting.map((x) => x.name).join(", ")}`) +
+            "\n" + GUTTER + dim("  /mcp shows the command each one runs · /mcp approve <name>")
+        );
+      }
+    } catch {
+      /* never block startup on this */
+    }
     // Task #127, Phase 3: if the base chat model server isn't answering, offer to set it up
     // (download + start mlx_lm.server). BC3: only runs when NOTHING answers — an already-up
     // model is left untouched, and this is skipped entirely. Interactive TTYs only.
@@ -11220,6 +11319,10 @@ async function main() {
       await runFullLogCommand(line);
       continue;
     }
+    if (line === "/mcp" || line.startsWith("/mcp ")) {
+      await runMcpSlashCommand(line);
+      continue;
+    }
     if (line === "/proxy" || line.startsWith("/proxy ")) {
       await runProxyCommand(line);
       continue;
@@ -11381,7 +11484,10 @@ async function main() {
     }
     // Any OTHER "/…" is a typo/unknown command — don't send it to the agent as a
     // question; point the user at /help (all real commands were handled above).
-    if (line.startsWith("/")) {
+    // …EXCEPT a skill (task #269): "/<skill> request" goes to the agent as typed, and the agent
+    // loads that skill's SKILL.md for the turn. Checked against the disk NOW, so a skill deleted a
+    // moment ago is an unknown command like any other, not an error.
+    if (line.startsWith("/") && !matchSkillCommand(line, currentSkills())) {
       const cmd = line.split(/\s+/)[0];
       console.log(GUTTER + dim(`unknown command: ${cmd} — type /help (or / then Tab) to list commands\n`));
       continue;