@tiens.nguyen/gu-cli 1.0.884 → 1.0.886

package/README.md

@@ -126,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 |

package/gu-repl.mjs

@@ -154,7 +154,7 @@ import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.m
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
 import { questionEchoText, thoughtPrintSeq, wrapDiffText } from "./terminal-layout.mjs";
 import { globalPrefixOf } from "./install-path.mjs";
-import { indentBlock, commandBlockRows } from "./terminal-layout.mjs"; // every line of an Allow-prompt detail indented (#189); wrapped + collapsible command (#204)
+import { indentBlock, commandBlockRows, wrapIndented } from "./terminal-layout.mjs"; // every line of an Allow-prompt detail indented (#189); wrapped + collapsible command (#204)
 import { firstGuOnPath, pathGuMismatch, guOnPathIsCurrent, updateAttemptRecord, repeatUpdateNotice } from "./update-verify.mjs";
 import { embedNotice, embedState, setupNoticeRows } from "./embed-model-command.mjs";
 import { HINTS, pickHint, hintRow, hintFits, HINT_AFTER_SECONDS } from "./hints.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" },
@@ -7711,6 +7714,14 @@ async function afterStoppedTurn({ taskLine, submittedInput, turnStartMs, stopped
   if (barPinned()) paintBar();
 }
 
+/**
+ * A message line under the gutter, cut to the terminal's width with a hanging indent (#293): a
+ * long line used to be left to the terminal, which wraps it back to COLUMN 0 ("…as they do ther" /
+ * "e."). `paint` colours each row after wrapping, so colour codes never count toward the width.
+ */
+function sayWrapped(text, paint = (s) => s, hang = "  ") {
+  for (const row of wrapIndented(String(text ?? ""), { width: commandWidth(), indent: GUTTER, hang })) console.log(paint(row));
+}
 /**
  * /switch-skill — whose skills, MCP servers and hooks THIS FOLDER uses (task #325): Claude Code's,
  * read where Claude keeps them (~/.claude, ./.claude, ~/.claude.json), or gu's own (~/.gonext,
@@ -7755,9 +7766,10 @@ async function runSwitchSkillCommand(line) {
     return;
   }
   _skillScan = { at: 0, skills: [] }; // the "/" menu and Tab follow at once
-  const say = (l) => console.log(GUTTER + l);
-  say(accent(`✓ ${pick === current ? "this folder uses" : "this folder now uses"} ${sourceLabel(pick)}`));
-  say(dim(`   skills, MCP servers and hooks are read from ${where(pick)}`));
+  // #293: wrapped under the line's own indent (never back to column 0); one 2-space indent under "✓".
+  const say = (text, paint) => sayWrapped(text, paint);
+  say(`✓ ${pick === current ? "this folder uses" : "this folder now uses"} ${sourceLabel(pick)}`, accent);
+  say(`  skills, MCP servers and hooks are read from ${where(pick)}`, dim);
   // What was found there — and what was not, said rather than shown as an empty list.
   try {
     const sk = discoverSkills({ cwd: process.cwd(), reserved: COMMAND_NAMES });
@@ -7766,27 +7778,165 @@ async function runSwitchSkillCommand(line) {
     const nHooks = (h) => Object.values(h).reduce((a, groups) => a + groups.reduce((b, g) => b + g.hooks.length, 0), 0);
     const count = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
     const running = mcp.servers.filter((x) => x.runnable).length;
-    say(dim(`  ${count(sk.skills.length, "skill")}${sk.skills.length ? ` (${sk.skills.map((x) => "/" + x.name).join(", ")})` : ""} · ${count(running, "MCP server")} · ${count(nHooks(hk.user) + (hk.projectApproved ? nHooks(hk.project) : 0), "hook")}`));
+    say(`  ${count(sk.skills.length, "skill")}${sk.skills.length ? ` (${sk.skills.map((x) => "/" + x.name).join(", ")})` : ""} · ${count(running, "MCP server")} · ${count(nHooks(hk.user) + (hk.projectApproved ? nHooks(hk.project) : 0), "hook")}`, dim);
     // Nothing there at all is a normal state, not a fault: say so, and that gu needs none of it.
     if (!sk.skills.length && !mcp.servers.length && !nHooks(hk.user) && !nHooks(hk.project) && !hk.notes.length) {
-      say(dim("   Nothing is set up there yet — gu works the same without any of them."));
+      say("  Nothing is set up there yet — gu works the same without any of them.", dim);
     }
-    for (const w of [...sk.warnings, ...mcp.warnings, ...hk.warnings]) say(yellow("  " + w));
+    for (const w of [...sk.warnings, ...mcp.warnings, ...hk.warnings]) say("  " + w, yellow);
     const unsupported = mcp.servers.filter((x) => x.error);
-    if (unsupported.length) say(yellow(`  ${count(unsupported.length, "MCP server")} cannot run here: ${unsupported.map((x) => `${x.name} (${x.error})`).join("; ")}`));
+    if (unsupported.length) say(`  ${count(unsupported.length, "MCP server")} cannot run here: ${unsupported.map((x) => `${x.name} (${x.error})`).join("; ")}`, yellow);
     const waiting = mcp.servers.filter((x) => x.scope === "project" && !x.approved && !x.error);
-    if (waiting.length) say(yellow(`  ${count(waiting.length, "project MCP server")} waiting for your approval: ${waiting.map((x) => x.name).join(", ")} — /mcp approve <name>`));
-    if (hk.projectPending) say(yellow(`   this folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them — /hooks approve`));
-    if (hk.notes.length) say(yellow(`  ${count(hk.notes.length, "hook")} in Claude's settings ${hk.notes.length === 1 ? "is" : "are"} NOT run by gu — /hooks says which and why`));
-    if (pick === "claude" && (nHooks(hk.user) || nHooks(hk.project))) say(dim("   Claude's hooks get Claude's event and tool names from gu, so they record here as they do there."));
+    if (waiting.length) say(`  ${count(waiting.length, "project MCP server")} waiting for your approval: ${waiting.map((x) => x.name).join(", ")} — /mcp approve <name>`, yellow);
+    if (hk.projectPending) say(`  this folder's ${hk.projectFile.replace(/^\.\//, "")} has hooks that will not run until you approve them — /hooks approve`, yellow);
+    if (hk.notes.length) say(`  ${count(hk.notes.length, "hook")} in Claude's settings ${hk.notes.length === 1 ? "is" : "are"} NOT run by gu — /hooks says which and why`, yellow);
+    if (pick === "claude" && (nHooks(hk.user) || nHooks(hk.project))) say("  Claude's hooks get Claude's event and tool names from gu, so they record here as they do there.", dim);
   } catch (err) {
-    say(yellow(`   (could not read it back: ${err.message})`));
+    say(`  (could not read it back: ${err.message})`, yellow);
   }
-  say(dim(`   It holds from your next question. ${pick === "claude" ? "/switch-skill gu" : "/switch-skill claude"} switches back.`));
+  say(`  It holds from your next question. ${pick === "claude" ? "/switch-skill gu" : "/switch-skill claude"} switches back.`, dim);
   console.log("");
   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;
+  }
+  // #293: Goal and Plan are long; wrapped under their own indent, not back to column 0.
+  for (const l of r.block.split("\n").filter((l) => !l.startsWith("If the user wants"))) {
+    if (l.startsWith("## ")) sayWrapped(l.slice(3), bold);
+    else sayWrapped(l, dim);
+  }
+  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
@@ -14808,6 +14958,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.
@@ -14995,6 +15152,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.884",
+  "version": "1.0.886",
   "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");
+}