@skein-code/cli 0.3.0 → 0.3.2

package/README.md

@@ -85,6 +85,10 @@ To install the published package from npm:
 npm install -g @skein-code/cli
 ```
 
+Once installed, upgrade in place with `skein update` (it detects your package
+manager and runs the matching global install). Add `--check` to only report a
+newer version, or `--yes` to skip the confirmation prompt.
+
 `skein` is the primary command. Existing installations can continue using
 `mosaic` or `mosaic-code`; the `.mosaic/` project state and `MOSAIC_*`
 environment variables remain compatible with this release.
@@ -224,6 +228,7 @@ skein --print [prompt]               headless agent run
 skein init                           project setup
 skein doctor                         prerequisite and fallback checks
 skein doctor --visual                terminal rendering and input calibration
+skein update                         upgrade to the latest release
 skein config show                    resolved, redacted configuration
 skein index                          build/update the selected index
 skein search <query>                 ranked grounded spans

package/dist/cli.js

@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.0",
+  version: "0.3.2",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,9 +236,8 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
-      "Guided first-run setup for official APIs and third-party relays",
-      "Protocol-aware OpenAI-compatible and Anthropic-compatible routing",
-      "Update notices now include a bounded summary of what changed"
+      "New: skein update self-upgrades to the latest release",
+      "Detects npm/pnpm/yarn/bun; --check reports only, --yes skips the prompt"
     ]
   },
   bin: {
@@ -11438,6 +11437,12 @@ function sliceDisplay(value, maxWidth) {
   }
   return output2;
 }
+function padDisplay(value, width) {
+  if (width <= 0) return "";
+  const truncated = truncateDisplay(value, width);
+  const pad = Math.max(0, width - displayWidth(truncated));
+  return truncated + " ".repeat(pad);
+}
 function compactDisplayPath(path, maxWidth = 54) {
   if (displayWidth(path) <= maxWidth) return path;
   const parts = path.split("/").filter(Boolean);
@@ -12531,23 +12536,21 @@ function ListPanel({ title, entries, width = 80, glyphMode = "auto", hideTitle =
       const labelLimit = entryDetail ? Math.max(1, Math.min(28, innerWidth - 4)) : innerWidth;
       const label = truncateDisplay(`${glyphs.bullet} ${entryLabel}`, labelLimit);
       if (rowWidth < 52 && entryDetail) {
+        const detailText2 = `  ${truncateDisplay(entryDetail, Math.max(1, innerWidth - 2))}`;
         return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-          /* @__PURE__ */ jsx(Text, { color, children: label }),
-          /* @__PURE__ */ jsx(Text, { color: theme.muted, children: `  ${truncateDisplay(entryDetail, Math.max(1, innerWidth - 2))}` })
+          /* @__PURE__ */ jsx(Text, { color, children: padDisplay(label, innerWidth) }),
+          /* @__PURE__ */ jsx(Text, { color: theme.muted, children: padDisplay(detailText2, innerWidth) })
         ] }, `${entry.label}-${index}`);
       }
       const detailLimit = Math.max(1, innerWidth - displayWidth(label) - 2);
+      const detailText = entryDetail ? truncateDisplay(entryDetail, detailLimit) : "";
+      const trailing = Math.max(0, innerWidth - displayWidth(label) - (entryDetail ? 2 + displayWidth(detailText) : 0));
       return /* @__PURE__ */ jsxs(Box, { children: [
         /* @__PURE__ */ jsx(Text, { color, children: label }),
-        entryDetail ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
-          "  ",
-          truncateDisplay(entryDetail, detailLimit)
-        ] }) : null
+        entryDetail ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: `  ${detailText}` }) : null,
+        trailing > 0 ? /* @__PURE__ */ jsx(Text, { children: " ".repeat(trailing) }) : null
       ] }, `${entry.label}-${index}`);
-    }) : /* @__PURE__ */ jsxs(Text, { color: theme.dim, children: [
-      glyphs.bullet,
-      " none"
-    ] })
+    }) : /* @__PURE__ */ jsx(Text, { color: theme.dim, children: padDisplay(`${glyphs.bullet} none`, innerWidth) })
   ] });
 }
 function MeterBar({ segments, total, width, glyphs }) {
@@ -17148,6 +17151,61 @@ function escapeXml2(value) {
   })[character] ?? character);
 }
 
+// src/utils/self-update.ts
+import { spawn as spawn2 } from "node:child_process";
+import { realpathSync } from "node:fs";
+var GLOBAL_INSTALL_ARGS = {
+  npm: (spec) => ["install", "-g", spec],
+  pnpm: (spec) => ["add", "-g", spec],
+  yarn: (spec) => ["global", "add", spec],
+  bun: (spec) => ["add", "-g", spec]
+};
+function detectPackageManager(binaryPath = process.argv[1], env = process.env) {
+  const fromAgent = parseUserAgent(env.npm_config_user_agent);
+  if (fromAgent) return fromAgent;
+  let resolved = binaryPath ?? "";
+  try {
+    if (resolved) resolved = realpathSync(resolved);
+  } catch {
+  }
+  const path = resolved.replace(/\\/g, "/").toLowerCase();
+  if (/(^|\/)\.bun\/|(^|\/)bun\//.test(path)) return "bun";
+  if (/(^|\/)pnpm(\/|-global\/|$)/.test(path)) return "pnpm";
+  if (/(^|\/)yarn\//.test(path)) return "yarn";
+  return "npm";
+}
+function parseUserAgent(agent) {
+  if (!agent) return null;
+  const name = agent.trim().split("/")[0]?.toLowerCase();
+  if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") return name;
+  return null;
+}
+function resolveUpgradePlan(options = {}) {
+  const env = options.env ?? process.env;
+  const spec = `${PACKAGE_NAME}@${options.version ?? "latest"}`;
+  const manager = detectPackageManager(options.binaryPath, env);
+  const args = GLOBAL_INSTALL_ARGS[manager](spec);
+  return { command: manager, args, manager, display: `${manager} ${args.join(" ")}` };
+}
+function upgradeCommandOverride(env = process.env) {
+  const raw = env.SKEIN_UPDATE_COMMAND ?? env.MOSAIC_UPDATE_COMMAND;
+  const trimmed = raw?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function runUpgrade(plan) {
+  return new Promise((resolve24) => {
+    const child = spawn2(plan.command, plan.args, {
+      stdio: "inherit",
+      shell: plan.shell ?? false
+    });
+    child.on("error", () => resolve24({ ok: false, exitCode: 127, display: plan.display }));
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      resolve24({ ok: exitCode === 0, exitCode, display: plan.display });
+    });
+  });
+}
+
 // src/cli.tsx
 var cliGlyphs = resolveCliGlyphs();
 var defaultWarningListeners = process.listeners("warning");
@@ -17251,6 +17309,63 @@ program.command("doctor").description("Diagnose prerequisites and safe fallbacks
   const ok = await runDoctor(config, { json: options.json === true, visual: options.visual === true });
   if (!ok) process.exitCode = 1;
 });
+program.command("update").description("Update to the latest published release").option("--check", "only report whether a newer version is available").option("--yes", "skip the confirmation prompt and upgrade immediately").option("--json", "print the result as JSON").action(async (options) => {
+  const json = options.json === true;
+  const current = package_default.version;
+  const notice = await refreshUpdateCache(current, { force: true }).catch(() => void 0);
+  if (!notice) {
+    if (json) printObject({ current, latest: current, upToDate: true }, true);
+    else process.stdout.write(`${chalk4.green(cliGlyphs.success)} Already on the latest release (v${current}).
+`);
+    return;
+  }
+  const override = upgradeCommandOverride();
+  const plan = override ? { command: override, args: [], manager: "custom", display: override, shell: true } : { ...resolveUpgradePlan({ version: notice.latest }), shell: false };
+  if (json && options.check === true) {
+    printObject({ current, latest: notice.latest, upToDate: false, command: plan.display, ...notice.highlights ? { highlights: notice.highlights } : {} }, true);
+    return;
+  }
+  process.stdout.write(`${chalk4.cyan(cliGlyphs.brand)} Update available ${chalk4.dim(`v${current}`)} ${cliGlyphs.separator} ${chalk4.green(`v${notice.latest}`)}
+`);
+  for (const highlight of notice.highlights ?? []) {
+    process.stdout.write(`  ${cliGlyphs.separator} ${highlight}
+`);
+  }
+  if (options.check === true) {
+    process.stdout.write(`  Run ${chalk4.cyan(`${PRODUCT_COMMAND} update`)} to install ${chalk4.dim(`(${plan.display})`)}.
+`);
+    return;
+  }
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (options.yes !== true) {
+    if (!interactive) {
+      process.stdout.write(`  Re-run with ${chalk4.cyan(`${PRODUCT_COMMAND} update --yes`)} to install ${chalk4.dim(`(${plan.display})`)}.
+`);
+      return;
+    }
+    const rl = createInterface2({ input, output });
+    try {
+      const answer = (await rl.question(`  Install ${chalk4.dim(plan.display)}? [Y/n] `)).trim().toLowerCase();
+      if (answer === "n" || answer === "no") {
+        process.stdout.write("  Update cancelled.\n");
+        return;
+      }
+    } finally {
+      rl.close();
+    }
+  }
+  process.stdout.write(`${chalk4.dim(`${cliGlyphs.running} ${plan.display}`)}
+`);
+  const result = await runUpgrade(plan);
+  if (result.ok) {
+    process.stdout.write(`${chalk4.green(cliGlyphs.success)} Updated to v${notice.latest}. Restart ${PRODUCT_COMMAND} to use it.
+`);
+  } else {
+    process.stdout.write(`${chalk4.red(cliGlyphs.error)} Update failed (exit ${result.exitCode}). Run ${chalk4.cyan(plan.display)} manually.
+`);
+    process.exitCode = 1;
+  }
+});
 program.command("migrate").description("Inspect or migrate legacy .mosaic state into .skein").option("-w, --workspace <path>", "workspace root").option("--json", "print a migration manifest as JSON").option("--yes", "perform the migration after conflict checks").option("--rollback", "verify and roll back a completed migration").option("--recover", "inspect or recover interrupted migration/rollback state").option("--home", "operate on the user-level Skein/Mosaic namespace").action(async (options) => {
   if (options.home && options.workspace) throw new Error("--workspace cannot be combined with --home.");
   if (options.recover && options.rollback) throw new Error("--recover and --rollback cannot be combined.");