@lexmanh/shed-cli 0.2.0-beta.8 → 0.3.0-beta.1

package/dist/cli.js

@@ -50,9 +50,9 @@ async function cleanCommand(path = ".", options = {}) {
       "Safe mode"
     );
   }
-  const spinner3 = p.spinner();
+  const spinner4 = p.spinner();
   verbose(`clean root: ${rootDir}, dryRun=${isDryRun}, hardDelete=${options.hardDelete ?? false}`);
-  spinner3.start(`Scanning ${rootDir} \u2026`);
+  spinner4.start(`Scanning ${rootDir} \u2026`);
   const scanner = new Scanner(defaultDetectors());
   const ctx = { scanRoot: rootDir, maxDepth: 8 };
   const [projects, globalItems] = await Promise.all([
@@ -64,7 +64,7 @@ async function cleanCommand(path = ".", options = {}) {
     ...globalItems
   ].filter((i) => options.includeRed || i.risk !== RiskTier.Red);
   verbose(`scan complete: ${allItems.length} cleanable items`);
-  spinner3.stop(`Found ${pc.bold(String(allItems.length))} cleanable items.`);
+  spinner4.stop(`Found ${pc.bold(String(allItems.length))} cleanable items.`);
   if (allItems.length === 0) {
     p.outro(pc.dim("Nothing to clean."));
     return;
@@ -209,8 +209,8 @@ async function cleanCommand(path = ".", options = {}) {
     }
   }
   console.log();
-  const outro6 = isDryRun ? `Dry-run complete. Run with ${pc.cyan("--execute")} to perform actual cleanup.` : result.failed.length > 0 ? `Completed with ${result.failed.length} failure(s).` : "All done!";
-  p.outro(outro6);
+  const outro7 = isDryRun ? `Dry-run complete. Run with ${pc.cyan("--execute")} to perform actual cleanup.` : result.failed.length > 0 ? `Completed with ${result.failed.length} failure(s).` : "All done!";
+  p.outro(outro7);
 }
 
 // src/commands/completions.ts
@@ -602,9 +602,9 @@ async function scanCommand(path = ".", options = {}) {
   if (!options.json) {
     p4.intro(pc4.bgCyan(pc4.black(" shed scan ")));
   }
-  const spinner3 = options.json ? null : p4.spinner();
+  const spinner4 = options.json ? null : p4.spinner();
   verbose(`scan root: ${rootDir}`);
-  spinner3?.start(`Scanning ${rootDir} \u2026`);
+  spinner4?.start(`Scanning ${rootDir} \u2026`);
   const scanStartedAt = Date.now();
   const scanner = new Scanner2(defaultDetectors2());
   const ctx = { scanRoot: rootDir, maxDepth: 8 };
@@ -622,7 +622,7 @@ async function scanCommand(path = ".", options = {}) {
   );
   for (const item of allItems)
     verbose(`  item: ${item.risk} ${item.path} (${item.sizeBytes} bytes)`);
-  spinner3?.stop(
+  spinner4?.stop(
     `Found ${pc4.bold(String(allItems.length))} cleanable items across ${projects.length} project(s).`
   );
   if (options.json) {
@@ -783,20 +783,281 @@ async function undoCommand() {
   p5.outro(pc5.green("Nothing to do \u2014 restore items via your OS Trash."));
 }
 
-// src/logo.ts
+// src/commands/upgrade.ts
+import * as p6 from "@clack/prompts";
+import { execa as execa2 } from "execa";
 import pc6 from "picocolors";
-var ART = [
+
+// src/update/detect-install.ts
+import { realpathSync } from "fs";
+import { constants, access } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var PACKAGE_NAME = "@lexmanh/shed-cli";
+function classifyInstall(resolvedPath) {
+  const p7 = resolvedPath.replace(/\\/g, "/").toLowerCase();
+  if (p7.includes("/_npx/") || p7.includes("/npx-cache/")) {
+    return {
+      kind: "npx",
+      note: "Running via npx (ephemeral). Re-run with `npx @lexmanh/shed-cli@latest`."
+    };
+  }
+  if (p7.includes("/bun/install/cache/") || p7.includes("/.bun/install/cache/")) {
+    return {
+      kind: "bunx",
+      note: "Running via bunx (ephemeral). Re-run with `bunx @lexmanh/shed-cli@latest`."
+    };
+  }
+  if (p7.includes("/.volta/") || p7.includes("/volta/tools/")) {
+    return { kind: "volta" };
+  }
+  if (p7.includes("/pnpm/global/") || p7.includes("/library/pnpm/") || p7.includes("/.local/share/pnpm/")) {
+    return { kind: "pnpm-global" };
+  }
+  if (p7.includes("/yarn/global/") || p7.includes("/.config/yarn/global/")) {
+    return { kind: "yarn-global" };
+  }
+  if (p7.includes("/.bun/install/global/")) {
+    return { kind: "bun-global" };
+  }
+  if (p7.includes("/node_modules/")) {
+    return { kind: "npm-global" };
+  }
+  return { kind: "unknown" };
+}
+function buildUpgradeCommand(kind, pkg = PACKAGE_NAME) {
+  switch (kind) {
+    case "npm-global":
+      return `npm i -g ${pkg}@latest`;
+    case "pnpm-global":
+      return `pnpm add -g ${pkg}@latest`;
+    case "yarn-global":
+      return `yarn global add ${pkg}@latest`;
+    case "bun-global":
+      return `bun add -g ${pkg}@latest`;
+    case "volta":
+      return `volta install ${pkg}@latest`;
+    case "npx":
+    case "bunx":
+    case "unknown":
+      return null;
+  }
+}
+function detectInstall(binPath) {
+  let resolvedPath;
+  try {
+    resolvedPath = realpathSync(binPath);
+  } catch {
+    resolvedPath = binPath;
+  }
+  const { kind, note: note7 } = classifyInstall(resolvedPath);
+  return {
+    kind,
+    upgradeCommand: buildUpgradeCommand(kind),
+    resolvedPath,
+    note: note7
+  };
+}
+async function needsElevation(resolvedPath) {
+  if (process.platform === "win32") return false;
+  try {
+    await access(dirname2(resolvedPath), constants.W_OK);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+// src/update/registry.ts
+import Conf2 from "conf";
+var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS = 3e3;
+function getCache() {
+  return new Conf2({ projectName: "shed", configName: "update-cache" });
+}
+function readCachedLatest() {
+  const last = getCache().get("lastCheck");
+  if (!last) return null;
+  if (Date.now() - last.checkedAt >= CACHE_TTL_MS) return null;
+  return last.version;
+}
+async function fetchLatestVersion(opts = {}) {
+  if (!opts.force) {
+    const cached = readCachedLatest();
+    if (cached) return cached;
+  }
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const res = await fetch(REGISTRY_URL, {
+      signal: ctrl.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(t);
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (!json.version) return null;
+    getCache().set("lastCheck", { version: json.version, checkedAt: Date.now() });
+    return json.version;
+  } catch {
+    return null;
+  }
+}
+function compareSemver(a, b) {
+  const [aMain, aPre = ""] = a.split("-");
+  const [bMain, bPre = ""] = b.split("-");
+  const aParts = (aMain ?? "").split(".").map((n2) => Number(n2) || 0);
+  const bParts = (bMain ?? "").split(".").map((n2) => Number(n2) || 0);
+  for (let i = 0; i < 3; i++) {
+    const x = aParts[i] ?? 0;
+    const y = bParts[i] ?? 0;
+    if (x !== y) return x - y;
+  }
+  if (aPre === "" && bPre === "") return 0;
+  if (aPre === "") return 1;
+  if (bPre === "") return -1;
+  const aP = aPre.split(".");
+  const bP = bPre.split(".");
+  const n = Math.max(aP.length, bP.length);
+  for (let i = 0; i < n; i++) {
+    const x = aP[i];
+    const y = bP[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xIsNum = /^\d+$/.test(x);
+    const yIsNum = /^\d+$/.test(y);
+    if (xIsNum && yIsNum) {
+      const diff = Number(x) - Number(y);
+      if (diff !== 0) return diff;
+    } else if (xIsNum) {
+      return -1;
+    } else if (yIsNum) {
+      return 1;
+    } else if (x !== y) {
+      return x > y ? 1 : -1;
+    }
+  }
+  return 0;
+}
+function isNewer(latest, current) {
+  return compareSemver(latest, current) > 0;
+}
+
+// src/commands/upgrade.ts
+async function upgradeCommand(opts, currentVersion) {
+  p6.intro(pc6.bgMagenta(pc6.black(" shed upgrade ")));
+  const install = detectInstall(process.argv[1] ?? "");
+  const spin = p6.spinner();
+  spin.start("Checking npm registry\u2026");
+  const latest = await fetchLatestVersion({ force: true });
+  spin.stop(latest ? `Latest: v${latest}` : "Could not reach registry");
+  if (!latest) {
+    p6.outro(pc6.yellow("No upgrade information available. Check your network and try again."));
+    process.exit(1);
+  }
+  if (!isNewer(latest, currentVersion)) {
+    p6.note(
+      `Installed:  ${pc6.cyan(`v${currentVersion}`)}
+Latest:     ${pc6.cyan(`v${latest}`)}`,
+      "Already up to date"
+    );
+    p6.outro(pc6.green("Nothing to do."));
+    return;
+  }
+  p6.note(
+    [
+      `Installed:  ${pc6.dim(`v${currentVersion}`)}`,
+      `Latest:     ${pc6.green(`v${latest}`)}`,
+      `Source:     ${pc6.cyan(install.kind)}`,
+      `Path:       ${pc6.dim(install.resolvedPath)}`
+    ].join("\n"),
+    "Upgrade available"
+  );
+  if (!install.upgradeCommand) {
+    p6.note(
+      install.note ?? "Could not detect how shed was installed.",
+      pc6.yellow("Cannot self-upgrade")
+    );
+    p6.outro(pc6.dim("Re-install manually using your preferred package manager."));
+    return;
+  }
+  const elevate = await needsElevation(install.resolvedPath);
+  const finalCommand = elevate ? `sudo ${install.upgradeCommand}` : install.upgradeCommand;
+  if (opts.check) {
+    p6.note(finalCommand, "Run this to upgrade");
+    p6.outro(pc6.dim("(--check mode: nothing executed)"));
+    return;
+  }
+  if (elevate) {
+    p6.note(finalCommand, pc6.yellow("Install dir is not writable \u2014 run this manually"));
+    p6.outro(pc6.dim("Re-run `shed upgrade` after the install completes to verify."));
+    return;
+  }
+  if (!opts.yes) {
+    const ok = await p6.confirm({ message: `Run \`${finalCommand}\` now?`, initialValue: true });
+    if (p6.isCancel(ok) || !ok) {
+      p6.cancel("Upgrade cancelled.");
+      return;
+    }
+  }
+  const runSpin = p6.spinner();
+  runSpin.start(`Running ${finalCommand}\u2026`);
+  try {
+    const [bin, ...args] = finalCommand.split(" ");
+    if (!bin) throw new Error("Empty upgrade command");
+    await execa2(bin, args, { stdio: "pipe" });
+    runSpin.stop(pc6.green(`Upgraded to v${latest}.`));
+    p6.outro(pc6.green("Done. Re-run `shed --version` to confirm."));
+  } catch (err) {
+    runSpin.stop(pc6.red("Upgrade failed."));
+    const message = err instanceof Error ? err.message : String(err);
+    p6.note(message, pc6.red("Error"));
+    p6.outro(pc6.dim(`You can retry manually: ${finalCommand}`));
+    process.exit(1);
+  }
+}
+
+// src/update/notifier.ts
+import pc7 from "picocolors";
+function maybeNotifyOfUpdate(currentVersion) {
+  const cached = readCachedLatest();
+  if (!cached || !isNewer(cached, currentVersion)) return;
+  const install = detectInstall(process.argv[1] ?? "");
+  const cmd = install.upgradeCommand ?? "shed upgrade";
+  const banner = [
+    pc7.yellow("\u25B2"),
+    pc7.dim(`shed v${currentVersion} \u2192`),
+    pc7.green(`v${cached}`),
+    pc7.dim("available."),
+    pc7.dim("Run"),
+    pc7.cyan("`shed upgrade`"),
+    pc7.dim(`(or \`${cmd}\`).`)
+  ].join(" ");
+  console.log(banner);
+}
+function scheduleBackgroundRefresh() {
+  if (readCachedLatest() !== null) return;
+  void fetchLatestVersion({ force: false, timeoutMs: 1500 }).catch(() => {
+  });
+}
+
+// src/logo.ts
+import pc8 from "picocolors";
+var CABIN = ["       \u2571\u2572    ", "      \u2571\u2500\u2500\u2572   ", "     \u2571\u2500\u2500\u2500\u2500\u2572  ", "     \u2502 \u2588\u2588 \u2502  ", "     \u2514\u2500\u2500\u2500\u2500\u2518  "];
+var WORDMARK = [
   "  ____  _              _ ",
   " / ___|| |__   ___  __| |",
   " \\___ \\| '_ \\ / _ \\/ _` |",
   "  ___) | | | |  __/ (_| |",
   " |____/|_| |_|\\___|\\__,_|"
-].join("\n");
+];
 function printLogo(version2) {
-  console.log(pc6.cyan(ART));
-  console.log(`  ${pc6.dim(`v${version2} \xB7 safe disk cleanup \xB7 dev machines & servers`)}`);
+  for (let i = 0; i < CABIN.length; i++) {
+    console.log(pc8.yellow(CABIN[i]) + pc8.cyan(WORDMARK[i]));
+  }
+  console.log(`  ${pc8.dim(`v${version2} \xB7 safe disk cleanup \xB7 dev machines & servers`)}`);
   console.log(
-    `  ${pc6.dim("by")} ${pc6.white("L\xEA Xu\xE2n M\u1EA1nh")} ${pc6.dim("\xB7 https://github.com/lexmanh/shed")}
+    `  ${pc8.dim("by")} ${pc8.white("L\xEA Xu\xE2n M\u1EA1nh")} ${pc8.dim("\xB7 https://github.com/lexmanh/shed")}
 `
   );
 }
@@ -812,12 +1073,19 @@ program.command("undo").description("List and restore items from previous cleanu
 program.command("doctor").description("Check environment and configuration").action(doctorCommand);
 program.command("config").description("Manage user preferences").argument("[action]", "get | set | list | reset").argument("[key]", "Configuration key").argument("[value]", "Configuration value (for set)").action(configCommand);
 program.command("completions").description("Print shell completion script").argument("<shell>", "bash | zsh | fish").action(completionsCommand);
+program.command("upgrade").alias("update").description("Check for and install the latest version of shed").option("--check", "Only check; print the upgrade command without running it").option("--yes", "Skip the confirmation prompt").action((opts) => upgradeCommand(opts, version));
 program.hook("preAction", (_thisCommand, actionCommand) => {
   const opts = program.opts();
   setVerbose(opts.verbose ?? false);
   const cmdOpts = actionCommand.opts();
-  const isCompletions = actionCommand.name() === "completions";
+  const cmdName = actionCommand.name();
+  const isCompletions = cmdName === "completions";
+  const isUpgrade = cmdName === "upgrade";
   if (!cmdOpts.json && !isCompletions) printLogo(version);
+  if (!cmdOpts.json && !isCompletions && !isUpgrade) {
+    maybeNotifyOfUpdate(version);
+    scheduleBackgroundRefresh();
+  }
 });
 program.parseAsync(process.argv).catch((err) => {
   console.error("shed: fatal error:", err instanceof Error ? err.message : err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexmanh/shed-cli",
-  "version": "0.2.0-beta.8",
+  "version": "0.3.0-beta.1",
   "description": "Safe disk cleanup CLI for dev machines and Linux servers — git-aware, cross-stack, trash-by-default",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
     "conf": "^13.1.0",
     "execa": "^9.5.0",
     "picocolors": "^1.1.1",
-    "@lexmanh/shed-core": "0.2.0-beta.8"
+    "@lexmanh/shed-core": "0.3.0-beta.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",