@tiens.nguyen/gu-cli 1.0.883 → 1.0.885

package/README.md

@@ -1,8 +1,8 @@
-<h1 align="center">gu — the coding agent in your terminal</h1>
+<h1 align="center">gu — the coding agent for your own models</h1>
 
 <p align="center">
-  <strong>It reads your repo, makes the change, and proves it works.</strong><br>
-  Your models — Ollama, MLX or any OpenAI-compatible provider. Your files stay in your folder.<br>
+  <strong>A coding agent in your terminal that runs on Ollama, MLX or any OpenAI-compatible API.</strong><br>
+  It reads your repo, makes the change, runs the tests and shows you what it did. Your code stays in your folder.<br>
   <strong>Free for 30 days. No account, no sign-in, no card.</strong>
 </p>
 
@@ -16,7 +16,7 @@
 
 <p align="center">
   <a href="https://gucli.com">Website</a> ·
-  <a href="https://gucli.com/docs">Docs</a> ·
+  <a href="https://gucli.com/start">Docs</a> ·
   <a href="https://gucli.com/pricing">Pricing</a> ·
   <a href="https://gucli.com/support">Support</a>
 </p>
@@ -42,19 +42,32 @@ provider to use. Then type what you want done.
 
 > **`gu: command not found`?** Run `npx @tiens.nguyen/gu-cli fix-path`. See [Troubleshooting](#troubleshooting).
 
-## What it does
-
-- **Writes the code, in your terminal.** Ask in plain words; gu reads the repo, edits the files,
-  runs the build and the tests, and tells you what it changed.
-- **Your models.** Run [Ollama](https://ollama.com) or MLX on your own machine, or bring any
-  OpenAI-compatible provider. Switch at any time with `/model`.
-- **It stays in the repo.** Every edit is a file you can read, diff and revert, and `/undo` puts
-  back what a stopped turn changed. No hidden workspace.
-- **Knows your codebase.** Local RAG indexes the folder so the model finds the right files.
-- **Extensible.** [MCP](https://modelcontextprotocol.io) servers, skills (`SKILL.md`), and hooks.
-  Already set up for Claude Code? `/switch-skill claude` reuses its `.claude` folder.
-- **Tests in a real browser.** The `browser` tool drives Chrome to check the web pages it builds.
-- **Private by default.** Logs hold no prompts, code or keys unless you run `gu --log`.
+## Why gu
+
+- **Your models, your choice.** Run [Ollama](https://ollama.com) or MLX on your own machine or a GPU
+  box on your network, or bring any OpenAI-compatible provider (OpenAI, DeepSeek, OpenRouter…). Use
+  one model to plan and another to code; switch any time with `/model`.
+- **Private by default.** Logs hold no prompts, code or keys unless you run `gu --log`. Need
+  everything in-house? Private mode runs the API and database on your own servers.
+- **It proves it works.** gu runs the build and the tests and fixes what fails. For web pages, the
+  `browser` tool drives a real Chrome and checks the result before gu says it is done.
+- **It stays in the repo.** Every edit is a file you can read, diff and revert; `/undo` puts back
+  what a stopped turn changed. No hidden workspace.
+- **Made for servers and SSH.** macOS, Linux and Windows, and it works over SSH in an 80-column
+  terminal, so you can run it where the code actually lives.
+- **Fits the setup you have.** [MCP](https://modelcontextprotocol.io) servers, skills (`SKILL.md`)
+  and hooks. Already use Claude Code? `/switch-skill claude` reuses its `.claude` folder. Local RAG
+  indexes the folder so the model finds the right files.
+
+## Is gu for you?
+
+**A good fit if** you run (or want to run) your own models, can't send code to someone else's
+cloud, work on remote Linux boxes over SSH, or want a coding agent that costs $4 a month instead
+of a model subscription.
+
+**Probably not if** you want the strongest frontier model with zero setup and don't mind where your
+code goes: the model vendors' own agents are simpler for that. gu can still use those models
+through an OpenAI-compatible API, but its strength is everything else.
 
 ## Quick start
 
@@ -113,6 +126,9 @@ Ctrl-C stops the running turn. Type `/` at the prompt to see every command; Tab
 | `/mcp [list\|tools\|add\|remove\|enable\|disable\|approve\|allow\|disallow\|reconnect]` | MCP servers, and which of their tools run without asking |
 | `/hooks [list\|approve\|unapprove]` | commands gu runs on `onStart`, `onAsk`, `onToolDone`, `onTurnEnd` |
 | `/switch-skill [claude\|gu]` | use Claude Code's (`.claude`) or gu's (`.gonext`) skills, MCP servers and hooks in this folder |
+| `/skill-pack <name> [--out <file>] [--runtime <dir>]` | pack a skill with its MCP servers, hooks and code into one zip for another machine (no venvs, databases or secrets) |
+| `/skill-install <zip\|folder> [--gu] [--claude] [--dry-run]` | install a packed skill for gu and Claude Code; without gu: `node <name>/install.mjs` |
+| `/resume` | carry on the last unfinished task in this folder, Claude Code's or gu's: shows its plan, last command and next step, then asks (needs the memory skill) |
 | `/skills-copy-to-claude [--dry-run] [name…]` | copy gu's skills into Claude Code's folders |
 | `/proxy [show\|set\|on\|off\|clear\|test]` | route model calls through an HTTP proxy (local calls go direct) |
 | `/s3 [test]` | use your own S3 bucket for the RAG index and generated files |
@@ -168,7 +184,7 @@ gu fix-path | fix-powershell   repair PATH / remove PowerShell's `gu` alias
 | --- | --- | --- |
 | **Free trial** | 30 days, starts on the first run | nothing: the token is created for you |
 | **Free plan** | 3 more months on that computer | a free account at [gucli.com](https://gucli.com) |
-| **Pro** | while subscribed | more computers, plus provider budgets |
+| **Pro** | while subscribed: **$4 a month** (110.000 ₫) + VAT, or $40 a year | the hosted agent and coder (no model server to run), up to 5 computers, provider budgets |
 
 Got a **voucher code**? Type `/voucher CODE` in gu (or enter it on your
 [account page](https://gucli.com/account)) for extra free days on top.

package/gu-repl.mjs

@@ -1051,6 +1051,9 @@ const COMMANDS = [
   { name: "/hooks", usage: "/hooks [list|approve|unapprove]", desc: "hooks: commands gu runs on onStart, onAsk, onToolDone, onTurnEnd — list them, approve this project's" },
   { 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: "/switch-skill", usage: "/switch-skill [claude|gu]", desc: "whose skills, MCP servers and hooks this folder uses — Claude Code's (.claude) or gu's own (.gonext)" },
+  { name: "/resume", desc: "carry on the last unfinished task in this folder — Claude Code's or gu's — from where it stopped (memory skill)" },
+  { name: "/skill-pack", usage: "/skill-pack <name> [--out <file>] [--runtime <dir>]", desc: "pack a skill (gu's or Claude's) with its MCP servers, hooks and code into one zip for another machine" },
+  { name: "/skill-install", usage: "/skill-install <zip|folder> [--gu] [--claude] [--dry-run]", desc: "install a packed skill for gu and Claude Code (whichever is set up here)" },
   { name: "/skills-copy-to-claude", usage: "/skills-copy-to-claude [--dry-run] [name…]", desc: "copy gu's skills (.gonext) into Claude Code's folders (.claude), renamed to Claude's names, with their MCP servers" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
@@ -7787,6 +7790,140 @@ async function runSwitchSkillCommand(line) {
   if (barPinned()) paintBar();
 }
 
+/** "--out x" style option from a command line's words → value, or undefined. */
+function optionValue(words, flag) {
+  const i = words.indexOf(flag);
+  return i >= 0 ? words[i + 1] : undefined;
+}
+
+/**
+ * /skill-pack <name> [--out <file>] [--runtime <dir>] — one skill, with its MCP servers, hooks and
+ * the code they run, into one zip another machine installs (#281, skill-package.mjs). Shows what
+ * it found, then writes; a secret-looking line refuses the pack.
+ */
+async function runResumeCommand() {
+  const rm = await import("./resume-memory.mjs");
+  const { hooksForTurn } = await import("./hooks-config.mjs");
+  const say = (l) => console.log(GUTTER + l);
+  console.log("");
+  const r = rm.readResume({ cwd: process.cwd(), found: rm.findMemoryCli({ cwd: process.cwd(), hooksFor: hooksForTurn }) });
+  if (r.error) {
+    say(yellow(r.error) + "\n");
+    return null;
+  }
+  if (!r.resume) {
+    say(dim("Nothing to resume here: every recent session finished its plan.\n"));
+    return null;
+  }
+  for (const l of r.block.split("\n").filter((l) => !l.startsWith("If the user wants"))) say(l.startsWith("## ") ? bold(l.slice(3)) : dim(l));
+  console.log("");
+  if (!(await askYesNo(rm.resumeQuestion(r.resume), true))) {
+    console.log("");
+    return null;
+  }
+  return rm.resumePrompt(r.block, r.resume);
+}
+
+async function runSkillPackCommand(line) {
+  const sp = await import("./skill-package.mjs");
+  const words = line.trim().split(/\s+/).slice(1);
+  const out = optionValue(words, "--out");
+  const runtime = optionValue(words, "--runtime");
+  const name = words.find((w, i) => !w.startsWith("--") && !["--out", "--runtime"].includes(words[i - 1]));
+  const home = homedir();
+  const cwd = resolve(process.cwd());
+  const tilde = (p) => (String(p).startsWith(home) ? "~" + String(p).slice(home.length) : p);
+  const say = (l) => console.log(GUTTER + l);
+  console.log("");
+  if (!name) {
+    say(dim("usage: /skill-pack <name> [--out <file>] [--runtime <dir>]\n"));
+    return;
+  }
+  let plan;
+  try {
+    plan = sp.planSkillPack(name, { cwd, home, runtime });
+  } catch (err) {
+    say(red(`${err.message}\n`));
+    return;
+  }
+  const f = plan.found;
+  say(bold(`Pack ${plan.manifest.name}`) + dim(`  (${f.source === "gu" ? "gu's" : "Claude Code's"} ${f.scope === "project" ? "project" : "user"} skill)`));
+  say(dim(`  skill    ${tilde(f.skillDir)}  ${plan.skill.size} file${plan.skill.size === 1 ? "" : "s"}`));
+  if (f.runtimeDir) say(dim(`  runtime  ${tilde(f.runtimeDir)}  ${plan.runtime.size} files${f.python ? " · venv rebuilt from requirements.txt" : ""}`));
+  for (const s of f.servers) say(dim(`  MCP      ${s}`));
+  if (f.hooks.length) say(dim(`  hooks    ${f.hooks.join(", ")}`));
+  if (plan.manifest.env?.length) say(dim(`  asked on install, not packed: ${plan.manifest.env.join(", ")}`));
+  if (plan.skipped.length) say(dim(`  left out ${plan.skipped.join(", ")}`));
+  for (const w of plan.warnings) say(yellow(`  ${w}`));
+  if (plan.secrets.length) {
+    for (const s of plan.secrets) say(red(`  ✗ ${s.file}:${s.line} looks like ${s.kind}`));
+    say(red("  Not packed — remove those and run /skill-pack again.\n"));
+    return;
+  }
+  const file = resolve(out ?? `${plan.manifest.name}.zip`);
+  try {
+    const r = sp.writeSkillPack(plan, file);
+    say(`${accent("✓")} ${tilde(r.file)} ${dim(`${Math.ceil(r.bytes / 1024)} KB, ${r.count} files`)}`);
+    say(dim(`   On the other machine:  /skill-install ${file.split(/[\\/]/).pop()}`));
+    // platform-ok: shown to the user — the folder inside the zip, which unzip makes with "/" names.
+    say(dim(`   Without gu:            unzip it, then node ${plan.manifest.name}/install.mjs\n`));
+  } catch (err) {
+    say(red(`couldn't write the zip — ${err.message}\n`));
+  }
+}
+
+/**
+ * /skill-install <zip|folder> [--gu] [--claude] [--dry-run] — a packed skill onto this machine
+ * (skill-install.mjs, the same code as the package's own install.mjs). Shows the plan, then asks.
+ */
+async function runSkillInstallCommand(line) {
+  const si = await import("./skill-install.mjs");
+  const words = line.trim().split(/\s+/).slice(1);
+  const src = words.find((w) => !w.startsWith("--"));
+  const targets = si.TARGETS.filter((t) => words.includes(`--${t}`));
+  const home = homedir();
+  const tilde = (p) => String(p).split(home).join("~");
+  const say = (l) => console.log(GUTTER + l);
+  console.log("");
+  if (!src) {
+    say(dim("usage: /skill-install <zip|folder> [--gu] [--claude] [--dry-run]\n"));
+    return;
+  }
+  let plan;
+  try {
+    plan = si.planInstall(si.loadPackage(resolve(src.replace(/^~(?=\/|$)/, home))), { home, targets });
+  } catch (err) {
+    say(red(`Not installed — ${err.message}\n`));
+    return;
+  }
+  const lines = si.describePlan(plan, tilde);
+  say(bold(lines[0]));
+  for (const l of lines.slice(1)) say(l.trimStart().startsWith("!") ? yellow(l) : dim(l));
+  if (!si.planHasWork(plan)) {
+    say(dim("\n   Nothing to do — it is already installed.\n"));
+    return;
+  }
+  if (words.includes("--dry-run")) {
+    say(dim("\n   --dry-run: nothing was written.\n"));
+    return;
+  }
+  console.log(dim(`\n   ${PICK_HINT}:`));
+  const options = ["Install", "Cancel"];
+  const idx = await pickFromList(options, 0);
+  if (idx !== 0) {
+    console.log(dim("   (cancelled — nothing installed)\n"));
+    paintBar();
+    return;
+  }
+  const r = si.applyInstall(plan, { say: (l) => say(dim(l)) });
+  for (const d of r.done) say(`${accent("✓")} ${dim(tilde(d))}`);
+  for (const e of r.errors) say(red(`✗ ${e}`));
+  if (r.backups) say(dim(`   Old copies: ${tilde(r.backups)}`));
+  if (!r.errors.length) say(dim(`   ${si.nextStep(plan)}`));
+  console.log("");
+  paintBar();
+}
+
 /**
  * /skills-copy-to-claude [--dry-run] [name…] — gu's skills into Claude Code's folders (#241):
  * ~/.gonext/skills → ~/.claude/skills and ./.gonext/skills → ./.claude/skills, "gu-" names become
@@ -14110,7 +14247,10 @@ async function main() {
       if (isClientExpert()) {
         try {
           const ceApi = await import("./client-expert-api.mjs");
-          apiBannerVersion = String((await ceApi.probeLocalApi()).body?.version ?? "").trim();
+          // The API this gu is configured for, on ITS port — not the default port, which another
+          // API (or none) may hold (#254: the banner differed between two machines).
+          const port = Number(new URL(apiBase).port) || undefined;
+          apiBannerVersion = String((await ceApi.probeLocalApi(port)).body?.version ?? "").trim();
         } catch { /* absent beats guessed — no suffix */ }
       }
       const statusRows = [
@@ -14805,6 +14945,13 @@ async function main() {
       console.log("\n" + GUTTER + dim(`⏺ background ${entries.length === 1 ? "shell" : "shells"} finished — ${entries.map((e) => `${e.rec.id} ${shellStatusText(e.st)}`).join(", ")} · gu asks the agent to recap`));
       lineRaw = recapQuestion(entries);
     }
+    // /resume (#285): show where the last unfinished session stopped; on "yes" the line becomes the
+    // prompt that carries it on, and the turn runs as if it had been typed.
+    if (lineRaw.trim() === "/resume") {
+      const prompt = await runResumeCommand();
+      if (!prompt) continue;
+      lineRaw = prompt;
+    }
     const line = lineRaw.trim();
     // #302: what was typed for THIS line (before expansion), and whether it was sent from a
     // stopped turn's restored question.
@@ -14992,6 +15139,14 @@ async function main() {
       await runSwitchSkillCommand(line);
       continue;
     }
+    if (line === "/skill-pack" || line.startsWith("/skill-pack ")) {
+      await runSkillPackCommand(line);
+      continue;
+    }
+    if (line === "/skill-install" || line.startsWith("/skill-install ")) {
+      await runSkillInstallCommand(line);
+      continue;
+    }
     if (line === "/skills-copy-to-claude" || line.startsWith("/skills-copy-to-claude ")) {
       await runSkillsCopyCommand(line);
       continue;

package/hooks-config.mjs

@@ -147,7 +147,9 @@ export function cleanHooks(raw, where, source = "gu") {
           ...(Number.isFinite(h.timeout) && h.timeout > 0 ? { timeout: h.timeout } : {}),
           ...(isObj(h.env) ? { env: Object.fromEntries(Object.entries(h.env).map(([k, v]) => [k, String(v)])) } : {}),
         }));
-      if (hs.length) kept.push({ matcher: String(g.matcher ?? ""), hooks: hs });
+      // #281: a group marked dialect "claude" (a packed skill's hook, installed for both tools) is
+      // spoken to in Claude's vocabulary, as if it had come from Claude Code's settings.
+      if (hs.length) kept.push({ matcher: String(g.matcher ?? ""), hooks: hs, ...(g.dialect === "claude" ? { dialect: "claude" } : {}) });
     }
     if (kept.length) hooks[event] = kept;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.883",
+  "version": "1.0.885",
   "description": "gu: the coding agent in your terminal. It reads your repo, makes the change and runs the tests, with your own models (Ollama, MLX or any OpenAI-compatible provider). macOS, Linux and Windows.",
   "keywords": [
     "ai",
@@ -146,6 +146,9 @@
     "skills.mjs",
     "skill-source.mjs",
     "skills-copy.mjs",
+    "skill-package.mjs",
+    "resume-memory.mjs",
+    "skill-install.mjs",
     "shell-details.mjs",
     "proc-identity.mjs",
     "win-path.mjs",

package/resume-memory.mjs

@@ -0,0 +1,85 @@
+/**
+ * gu /resume (#285): where the last unfinished session in this project stopped — Claude Code's or
+ * gu's — read from the session-memory skill's database, so gu can carry on Claude's work.
+ *
+ * The memory skill is found through the hooks this folder uses (its memory_hook.py sits next to
+ * memory_cli.py), so whichever copy is installed — ~/.claude/memory, a /skill-install runtime —
+ * is the one asked. Nothing here writes the database.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+const SKILL = "claude-session-memory-orchestration";
+
+/** {python, cli} of the memory skill, or null when it is not installed. */
+export function findMemoryCli({ cwd = process.cwd(), home = homedir(), hooksFor } = {}) {
+  for (const source of [undefined, "claude", "gu"]) {
+    let hooks = {};
+    try {
+      hooks = hooksFor ? hooksFor({ cwd, home, source }) : {};
+    } catch {
+      continue;
+    }
+    for (const groups of Object.values(hooks)) {
+      for (const g of groups ?? []) {
+        for (const h of g.hooks ?? []) {
+          const script = [h.command, ...(h.args ?? [])].find((a) => /memory_hook\.py$/.test(String(a)));
+          if (!script) {continue;}
+          const cli = join(dirname(dirname(String(script))), "memory_cli.py");
+          if (existsSync(cli)) {return { python: String(h.command).endsWith(".py") ? pythonFor(cli) : String(h.command), cli };}
+        }
+      }
+    }
+  }
+  for (const dir of [join(home, ".gonext", "skill-runtime", SKILL), join(home, ".claude", "skill-runtime", SKILL), join(home, ".claude", "memory")]) {
+    const cli = join(dir, "memory_cli.py");
+    if (existsSync(cli)) {return { python: pythonFor(cli), cli };}
+  }
+  return null;
+}
+
+function pythonFor(cli) {
+  const dir = dirname(cli);
+  for (const p of [join(dir, ".venv", "bin", "python"), join(dir, ".venv", "Scripts", "python.exe")]) {if (existsSync(p)) {return p;}}
+  return process.platform === "win32" ? "python" : "python3"; // platform-ok: the venv is preferred above
+}
+
+/** {block, resume} from `memory_cli.py resume --json`, or {error}. */
+export function readResume({ cwd = process.cwd(), found, run = spawnSync } = {}) {
+  if (!found) {return { error: "the memory skill is not installed here — /skill-install claude-session-memory-orchestration.zip" };}
+  const r = run(found.python, [found.cli, "resume", "--json"], { cwd, encoding: "utf8", timeout: 20000 });
+  if (r.error || r.status !== 0) {return { error: `memory_cli resume failed: ${(r.error?.message || r.stderr || "").trim().split("\n").pop()}` };}
+  try {
+    const d = JSON.parse(r.stdout);
+    return { block: d.block || "", resume: d.resume ?? null };
+  } catch {
+    return { error: "memory_cli resume printed something that is not JSON" };
+  }
+}
+
+/** The step to offer: the saved next action, else the first plan step not done. */
+export function nextStepOf(resume) {
+  if (!resume) {return "";}
+  const open = (resume.plan ?? []).find((p) => p.status !== "completed");
+  return String(resume.next_action || open?.text || resume.task?.next_action || "").trim();
+}
+
+/** The question asked before carrying on. */
+export function resumeQuestion(resume) {
+  const step = nextStepOf(resume);
+  const what = resume?.task?.id ? `task #${resume.task.id}` : "this work";
+  return step ? `Continue ${what} from "${step.length > 60 ? step.slice(0, 59) + "…" : step}"?` : `Continue ${what}?`;
+}
+
+/** What the agent is sent on "yes": the block itself, and what to do with it. */
+export function resumePrompt(block, resume) {
+  const step = nextStepOf(resume);
+  return [
+    `Continue the unfinished work below${resume?.task?.id ? ` (task #${resume.task.id})` : ""}. It was saved by the memory skill${resume?.tool === "claude" ? " from a Claude Code session" : ""}.`,
+    step ? `Start from: ${step}. Check the files it lists first; do not redo steps marked ✓.` : "Check the files it lists first; do not redo steps marked ✓.",
+    "",
+    block,
+  ].join("\n");
+}