@tiens.nguyen/gu-cli 1.0.872 → 1.0.874

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.872",
+  "version": "1.0.874",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -134,6 +134,7 @@
     "update-verify.mjs",
     "skills.mjs",
     "skill-source.mjs",
+    "skills-copy.mjs",
     "shell-details.mjs",
     "proc-identity.mjs",
     "win-path.mjs",

package/skills-copy.mjs

@@ -0,0 +1,266 @@
+/**
+ * /skills-copy-to-claude — copy gu's skills into Claude Code's folders, under Claude's names (#241).
+ *
+ *   ~/.gonext/skills/<name>/          →  ~/.claude/skills/<claude-name>/
+ *   <project>/.gonext/skills/<name>/  →  <project>/.claude/skills/<claude-name>/
+ *   the skill's MCP server in ~/.gonext/mcp.json  →  ~/.claude.json
+ *       (user scope for a home skill, projects["<folder>"] for a project skill)
+ *
+ * The web-v2 Skills page's installer (#208, src/skills/email/install.mjs) puts a skill's files into
+ * ~/.gonext/skills/<name>/ and its MCP server into ~/.gonext/mcp.json. This is the same move in the
+ * other direction, so a skill set up for gu also works in Claude Code.
+ *
+ * NAMES. gu's own skills start with "gu-" where Claude's start with "claude-" (the memory skill is
+ * gu-session-memory-orchestration here and claude-session-memory-orchestration there). So "gu-"
+ * becomes "claude-" in the folder name, the frontmatter `name:` and the text. Other names stay.
+ *
+ * TEXT. Only SKILL.md is rewritten, and only what is certain: paths into the skill's own folder
+ * (they now point at the copy) and the old name. Other mentions of .gonext (gu's memory CLI, say)
+ * may have no Claude equivalent, so they are left as they are and REPORTED, never guessed.
+ *
+ * A COPY. Nothing under ~/.gonext changes. Claude's file ~/.claude.json is changed only through
+ * updateClaudeConfig, and only its mcpServers. A Claude skill that differs is kept unless the user
+ * chose "replace"; a replaced folder goes to ~/.gonext/skills-copy-backups/<time>/, never next to
+ * the others in .claude/skills, where Claude would load it as a second skill.
+ */
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative, resolve, sep } from "node:path";
+import { scanSkillsDir } from "./skills.mjs";
+import { readClaudeServers, readUserConfig, updateClaudeConfig } from "./mcp-config.mjs";
+
+export const BACKUP_DIR_NAME = "skills-copy-backups";
+
+/** Claude's name for a gu skill: "gu-" → "claude-", else the same. Kept within Claude's 64. */
+export function claudeSkillName(name) {
+  const n = String(name);
+  return n.startsWith("gu-") ? `claude-${n.slice(3)}`.slice(0, 64) : n;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/**
+ * SKILL.md for Claude: its own-folder paths and its old name rewritten. → { text, guLines }
+ * guLines = line numbers (1-based) that still mention .gonext after the rewrite — for the user to check.
+ */
+export function rewriteSkillText(text, { from, to }) {
+  let out = String(text);
+  // ".gonext/skills/<from>" in any form (~/, $HOME/, an absolute home, ./, Windows backslashes).
+  const pathRe = new RegExp(`\\.gonext([\\\\/])skills\\1${escapeRe(from)}(?![a-z0-9-])`, "g");
+  out = out.replace(pathRe, (_m, s) => `.claude${s}skills${s}${to}`);
+  if (to !== from) {
+    // The name itself: in the frontmatter, as /<name>, in use_skill("<name>")…
+    const nameRe = new RegExp(`(?<![a-z0-9-])${escapeRe(from)}(?![a-z0-9-])`, "g");
+    out = out.replace(nameRe, to);
+  }
+  const guLines = out
+    .split("\n")
+    .map((l, i) => (/\.gonext\b/.test(l) ? i + 1 : 0))
+    .filter(Boolean);
+  return { text: out, guLines };
+}
+
+/**
+ * `p` inside `dir` → the same path inside `toDir`, else null. Slashes and (on Windows) case are
+ * ignored when comparing, and a leading ~ counts as the home folder.
+ */
+export function movePath(p, dir, toDir, { home = homedir(), platform = process.platform } = {}) {
+  if (typeof p !== "string" || !p) return null;
+  const expanded = /^~(?=$|[\\/])/.test(p) ? home + p.slice(1) : p;
+  const norm = (s) => {
+    const x = s.replace(/\\/g, "/").replace(/\/+$/, "");
+    return platform === "win32" ? x.toLowerCase() : x;
+  };
+  const a = norm(expanded);
+  const d = norm(dir);
+  if (a !== d && !a.startsWith(d + "/")) return null;
+  const rest = expanded.replace(/\\/g, "/").replace(/\/+$/, "").slice(d.length).replace(/^\//, "");
+  const s = platform === "win32" ? "\\" : "/";
+  const base = toDir.replace(/[\\/]+$/, "");
+  return rest ? base + s + rest.split("/").join(s) : base;
+}
+
+/** An MCP entry with every path into the skill folder moved to the copy. → { entry, linked } */
+export function moveServerEntry(entry, fromDir, toDir, opts) {
+  let linked = false;
+  const mv = (v) => {
+    const m = movePath(v, fromDir, toDir, opts);
+    if (m == null) return v;
+    linked = true;
+    return m;
+  };
+  const out = { ...entry };
+  if (typeof out.command === "string") out.command = mv(out.command);
+  if (Array.isArray(out.args)) out.args = out.args.map((a) => (typeof a === "string" ? mv(a) : a));
+  if (out.env && typeof out.env === "object") {
+    out.env = Object.fromEntries(Object.entries(out.env).map(([k, v]) => [k, typeof v === "string" ? mv(v) : v]));
+  }
+  if (typeof out.cwd === "string") out.cwd = mv(out.cwd);
+  return { entry: out, linked };
+}
+
+/** Every file of a folder (following links), as relative path → { data, mode }. .DS_Store left out. */
+function readTree(dir) {
+  const files = new Map();
+  const walk = (d) => {
+    for (const name of readdirSync(d)) {
+      if (name === ".DS_Store") continue;
+      const p = join(d, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue; // a dangling link
+      }
+      if (st.isDirectory()) walk(p);
+      else if (st.isFile()) files.set(relative(dir, p).split(sep).join("/"), { data: readFileSync(p), mode: st.mode & 0o777 });
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+function sameTree(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [k, v] of a) {
+    const w = b.get(k);
+    if (!w || !w.data.equals(v.data)) return false;
+  }
+  return true;
+}
+
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const sameJson = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+/**
+ * What would be copied. Reads only. `names` (gu's or Claude's names) narrows it to those skills.
+ *
+ * → { items: [{ name, newName, scope, from, to, status: "new"|"same"|"differs", guLines, files,
+ *               servers: [{ name, scope, entry, status }] }],
+ *     warnings, missing: names asked for that gu does not have }
+ */
+export function planSkillsCopy({ cwd = process.cwd(), home = homedir(), names = [], platform = process.platform } = {}) {
+  const dirs = [{ scope: "user", from: join(home, ".gonext", "skills"), to: join(home, ".claude", "skills") }];
+  if (cwd && resolve(cwd) !== resolve(home)) {
+    dirs.push({ scope: "project", from: join(cwd, ".gonext", "skills"), to: join(cwd, ".claude", "skills") });
+  }
+  const gu = readUserConfig(home);
+  const claude = readClaudeServers({ cwd, home });
+  const warnings = [];
+  if (gu.error) warnings.push(`~/.gonext/mcp.json is ${gu.error} — no MCP servers are copied with the skills`);
+  if (claude.error) warnings.push(`~/.claude.json is ${claude.error} — no MCP servers can be copied into it`);
+
+  const wanted = new Set(names.map((n) => String(n).replace(/^\//, "")));
+  const items = [];
+  for (const d of dirs) {
+    const scan = scanSkillsDir(d.from, d.scope);
+    warnings.push(...scan.warnings);
+    for (const s of scan.skills) {
+      const newName = claudeSkillName(s.name);
+      if (wanted.size && !wanted.has(s.name) && !wanted.has(newName)) continue;
+      const folder = s.dir.split(/[\\/]/).pop();
+      const to = join(d.to, newName);
+      const files = readTree(s.dir);
+      const md = files.get("SKILL.md");
+      const rewritten = rewriteSkillText(md.data.toString("utf8"), { from: s.name, to: newName });
+      // A folder named differently from its frontmatter name: rewrite its paths too.
+      const text = folder !== s.name ? rewriteSkillText(rewritten.text, { from: folder, to: newName }) : rewritten;
+      files.set("SKILL.md", { data: Buffer.from(text.text, "utf8"), mode: md.mode });
+
+      let status = "new";
+      if (existsSync(to)) status = sameTree(files, readTree(to)) ? "same" : "differs";
+
+      const servers = [];
+      if (!gu.error && !claude.error) {
+        const have = d.scope === "project" ? claude.local : claude.user;
+        for (const [sname, entry] of Object.entries(gu.mcpServers)) {
+          if (!isObj(entry)) continue;
+          const moved = moveServerEntry(entry, s.dir, to, { home, platform });
+          if (!moved.linked) continue;
+          const st = !(sname in have) ? "new" : sameJson(have[sname], moved.entry) ? "same" : "differs";
+          servers.push({ name: sname, scope: d.scope === "project" ? "local" : "user", entry: moved.entry, status: st });
+        }
+      }
+      items.push({ name: s.name, newName, scope: d.scope, from: s.dir, to, status, guLines: text.guLines, files, servers });
+    }
+  }
+  const have = new Set(items.flatMap((i) => [i.name, i.newName]));
+  const missing = [...wanted].filter((n) => !have.has(n));
+  return { items, warnings, missing };
+}
+
+function writeTree(dir, files) {
+  for (const [rel, f] of files) {
+    const p = join(dir, ...rel.split("/"));
+    mkdirSync(join(p, ".."), { recursive: true });
+    writeFileSync(p, f.data, { mode: f.mode || 0o644 });
+  }
+}
+
+/** Move a folder; across disks, copy then remove. */
+function moveDir(from, to) {
+  mkdirSync(join(to, ".."), { recursive: true });
+  try {
+    renameSync(from, to);
+  } catch {
+    cpSync(from, to, { recursive: true });
+    rmSync(from, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Do it. `replace` = also overwrite skills and servers Claude has in a different version (the old
+ * folder is backed up first). → { done: [{ name, newName, to, action, backup? }],
+ *                                 servers: [{ name, scope, action }], errors: string[] }
+ * action: "copied" | "replaced" | "kept" | "already"
+ */
+export function applySkillsCopy(plan, { replace = false, cwd = process.cwd(), home = homedir(), now = new Date() } = {}) {
+  const stamp = now.toISOString().replace(/[:.]/g, "-");
+  const backupRoot = join(home, ".gonext", BACKUP_DIR_NAME, stamp);
+  const done = [];
+  const servers = [];
+  const errors = [];
+  for (const it of plan.items) {
+    try {
+      if (it.status === "same") done.push({ name: it.name, newName: it.newName, to: it.to, action: "already" });
+      else if (it.status === "differs" && !replace) done.push({ name: it.name, newName: it.newName, to: it.to, action: "kept" });
+      else {
+        let backup;
+        if (it.status === "differs") {
+          backup = join(backupRoot, it.scope, it.newName);
+          moveDir(it.to, backup);
+        }
+        mkdirSync(it.to, { recursive: true });
+        writeTree(it.to, it.files);
+        done.push({ name: it.name, newName: it.newName, to: it.to, action: backup ? "replaced" : "copied", ...(backup ? { backup } : {}) });
+      }
+    } catch (err) {
+      errors.push(`${it.name}: ${err.message}`);
+      continue;
+    }
+    const write = it.servers.filter((s) => s.status === "new" || (s.status === "differs" && replace));
+    for (const s of it.servers) {
+      if (!write.includes(s)) servers.push({ name: s.name, scope: s.scope, action: s.status === "same" ? "already" : "kept" });
+    }
+    if (!write.length) continue;
+    try {
+      updateClaudeConfig((raw) => {
+        for (const s of write) {
+          let into;
+          if (s.scope === "local") {
+            raw.projects = isObj(raw.projects) ? raw.projects : {};
+            const key = resolve(cwd);
+            raw.projects[key] = isObj(raw.projects[key]) ? raw.projects[key] : {};
+            into = raw.projects[key];
+          } else into = raw;
+          into.mcpServers = isObj(into.mcpServers) ? into.mcpServers : {};
+          into.mcpServers[s.name] = s.entry;
+        }
+      }, home);
+      for (const s of write) servers.push({ name: s.name, scope: s.scope, action: s.status === "differs" ? "replaced" : "copied" });
+    } catch (err) {
+      errors.push(`MCP ${write.map((s) => s.name).join(", ")}: ${err.message}`);
+    }
+  }
+  return { done, servers, errors, backupRoot };
+}

package/skills.mjs

@@ -94,6 +94,9 @@ function isDir(p) {
 }
 
 /** One skills folder → { skills, warnings }. A folder that is not there is simply empty. */
+export function scanSkillsDir(dir, scope) {
+  return scanDir(dir, scope);
+}
 function scanDir(dir, scope) {
   const skills = [];
   const warnings = [];