@lexmanh/shed-cli 0.2.0-beta.1

package/dist/cli.js

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/clean.ts
+import { resolve } from "path";
+import * as p from "@clack/prompts";
+import {
+  AndroidDetector,
+  CocoaPodsDetector,
+  DockerDetector,
+  FlutterDetector,
+  IdeDetector,
+  NodeDetector,
+  PythonDetector,
+  RiskTier,
+  RustDetector,
+  SafetyChecker,
+  Scanner,
+  XcodeDetector
+} from "@lexmanh/shed-core";
+import pc from "picocolors";
+
+// src/verbose.ts
+var _verbose = false;
+function setVerbose(v) {
+  _verbose = v;
+}
+function verbose(msg) {
+  if (_verbose) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    process.stderr.write(`[${ts}] ${msg}
+`);
+  }
+}
+
+// src/commands/clean.ts
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+var RISK_BADGE = {
+  [RiskTier.Green]: pc.green("Green "),
+  [RiskTier.Yellow]: pc.yellow("Yellow"),
+  [RiskTier.Red]: pc.red("Red   ")
+};
+async function cleanCommand(path = ".", options = {}) {
+  const rootDir = resolve(path);
+  const isDryRun = !options.execute;
+  p.intro(pc.bgYellow(pc.black(" shed clean ")));
+  if (isDryRun) {
+    p.note(
+      "DRY-RUN mode \u2014 no files will be deleted.\nPass --execute to perform actual cleanup.",
+      "Safe mode"
+    );
+  }
+  const spinner3 = p.spinner();
+  verbose(`clean root: ${rootDir}, dryRun=${isDryRun}, hardDelete=${options.hardDelete ?? false}`);
+  spinner3.start(`Scanning ${rootDir} \u2026`);
+  const scanner = new Scanner([
+    new NodeDetector(),
+    new PythonDetector(),
+    new RustDetector(),
+    new DockerDetector(),
+    new XcodeDetector(),
+    new FlutterDetector(),
+    new AndroidDetector(),
+    new CocoaPodsDetector(),
+    new IdeDetector()
+  ]);
+  const ctx = { scanRoot: rootDir, maxDepth: 8 };
+  const [projects, globalItems] = await Promise.all([
+    scanner.scan(rootDir),
+    scanner.scanGlobal(ctx)
+  ]);
+  const allItems = [
+    ...projects.flatMap((proj) => proj.items),
+    ...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.`);
+  if (allItems.length === 0) {
+    p.outro(pc.dim("Nothing to clean."));
+    return;
+  }
+  const checker = new SafetyChecker();
+  const checkResults = await Promise.all(allItems.map((item) => checker.check(item)));
+  const eligibleItems = allItems.filter((_, i) => {
+    const result2 = checkResults[i];
+    return result2?.allowed ?? false;
+  });
+  const blockedItems = allItems.filter((_, i) => {
+    const result2 = checkResults[i];
+    return !(result2?.allowed ?? false);
+  });
+  if (blockedItems.length > 0) {
+    p.note(
+      blockedItems.map((item) => {
+        const reasons = checkResults[allItems.indexOf(item)]?.reasons ?? [];
+        const blockReason = reasons.find((r) => r.severity === "block");
+        return `${pc.dim(item.path)}
+  ${pc.red("\u2717")} ${blockReason?.message ?? "blocked"}`;
+      }).join("\n\n"),
+      `${blockedItems.length} item(s) blocked by safety checks`
+    );
+  }
+  if (eligibleItems.length === 0) {
+    p.outro(pc.yellow("All items were blocked by safety checks."));
+    return;
+  }
+  let selectedItems = eligibleItems;
+  if (!options.yes) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const greenItems = eligibleItems.filter((i) => i.risk === RiskTier.Green);
+    const yellowItems = eligibleItems.filter((i) => i.risk === RiskTier.Yellow);
+    const greenBytes = greenItems.reduce((s, i) => s + i.sizeBytes, 0);
+    const yellowBytes = yellowItems.reduce((s, i) => s + i.sizeBytes, 0);
+    const allBytes = eligibleItems.reduce((s, i) => s + i.sizeBytes, 0);
+    const preset = await p.select({
+      message: "What would you like to clean?",
+      options: [
+        {
+          value: "all",
+          label: `All  ${pc.dim(`${eligibleItems.length} items \xB7 ${formatBytes(allBytes)}`)}`
+        },
+        ...greenItems.length > 0 ? [
+          {
+            value: "green",
+            label: `${pc.green("Green only")}  ${pc.dim(`${greenItems.length} items \xB7 ${formatBytes(greenBytes)} \xB7 safest`)}`
+          }
+        ] : [],
+        ...yellowItems.length > 0 ? [
+          {
+            value: "yellow",
+            label: `${pc.yellow("Yellow only")}  ${pc.dim(`${yellowItems.length} items \xB7 ${formatBytes(yellowBytes)}`)}`
+          }
+        ] : [],
+        { value: "custom", label: "Custom  (pick individual items)" }
+      ]
+    });
+    if (p.isCancel(preset)) {
+      p.cancel("Cleanup cancelled.");
+      return;
+    }
+    if (preset === "all") {
+      selectedItems = eligibleItems;
+    } else if (preset === "green") {
+      selectedItems = greenItems;
+    } else if (preset === "yellow") {
+      selectedItems = yellowItems;
+    } else {
+      const choices = eligibleItems.map((item) => {
+        const displayPath = home ? item.path.replace(home, "~") : item.path;
+        const warnings = checkResults[allItems.indexOf(item)]?.reasons.filter(
+          (r) => r.severity === "warning"
+        ) ?? [];
+        const warnStr = warnings.length > 0 ? pc.yellow(` \u26A0 ${warnings.map((w) => w.message).join("; ")}`) : "";
+        return {
+          value: item,
+          label: `${RISK_BADGE[item.risk]}  ${displayPath}  ${pc.dim(formatBytes(item.sizeBytes))}${warnStr}`
+        };
+      });
+      const selection = await p.multiselect({
+        message: "Select items to clean (space to toggle, enter to confirm):",
+        options: choices,
+        required: false
+      });
+      if (p.isCancel(selection)) {
+        p.cancel("Cleanup cancelled.");
+        return;
+      }
+      selectedItems = selection;
+    }
+  }
+  if (selectedItems.length === 0) {
+    p.outro(pc.dim("Nothing selected."));
+    return;
+  }
+  const totalBytes = selectedItems.reduce((s, i) => s + i.sizeBytes, 0);
+  if (!isDryRun && !options.yes) {
+    const action = options.hardDelete ? pc.red("PERMANENTLY DELETE") : "move to Trash";
+    const confirmed = await p.confirm({
+      message: `${action} ${selectedItems.length} item(s) (${formatBytes(totalBytes)})?`,
+      initialValue: false
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("Cleanup cancelled.");
+      return;
+    }
+  }
+  verbose(
+    `executing ${selectedItems.length} items, dryRun=${isDryRun}, hardDelete=${options.hardDelete ?? false}`
+  );
+  for (const item of selectedItems) verbose(`  \u2192 ${item.path}`);
+  const execSpinner = p.spinner();
+  execSpinner.start(isDryRun ? "Simulating cleanup \u2026" : "Cleaning up \u2026");
+  const result = await checker.execute(selectedItems, {
+    dryRun: isDryRun,
+    hardDelete: options.hardDelete ?? false,
+    includeRed: options.includeRed ?? false
+  });
+  execSpinner.stop(isDryRun ? "Dry-run complete." : "Cleanup complete.");
+  if (result.succeeded.length > 0) {
+    const verb = isDryRun ? "Would free" : "Freed";
+    console.log(
+      `
+  ${pc.green("\u2713")} ${verb} ${pc.bold(pc.green(formatBytes(result.totalBytesFreed)))} across ${result.succeeded.length} item(s).`
+    );
+  }
+  if (result.skipped.length > 0) {
+    console.log(`  ${pc.yellow("\u26A0")} ${result.skipped.length} item(s) skipped.`);
+    for (const s of result.skipped) {
+      const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+      const displayPath = home ? s.item.path.replace(home, "~") : s.item.path;
+      console.log(`    ${pc.dim(displayPath)}: ${s.reason}`);
+    }
+  }
+  if (result.failed.length > 0) {
+    console.log(`  ${pc.red("\u2717")} ${result.failed.length} item(s) failed:`);
+    for (const f of result.failed) {
+      console.log(`    ${pc.dim(f.item.path)}: ${f.error}`);
+    }
+  }
+  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);
+}
+
+// src/commands/config.ts
+import * as p2 from "@clack/prompts";
+import Conf from "conf";
+import pc2 from "picocolors";
+var DEFAULTS = {
+  scan: { maxDepth: 8, maxAgeDays: 30 },
+  clean: { hardDelete: false },
+  ai: { provider: "anthropic", model: "claude-opus-4-7" }
+};
+var KEY_DEFS = {
+  "scan.maxDepth": { get: (s) => s.scan.maxDepth, description: "Max filesystem depth for scan" },
+  "scan.maxAgeDays": {
+    get: (s) => s.scan.maxAgeDays,
+    description: "Min age (days) before item is surfaced"
+  },
+  "clean.hardDelete": {
+    get: (s) => s.clean.hardDelete,
+    description: "Permanently delete instead of Trash"
+  },
+  "ai.provider": {
+    get: (s) => s.ai.provider,
+    description: "AI provider (anthropic|openai|ollama)"
+  },
+  "ai.model": { get: (s) => s.ai.model, description: "AI model name" }
+};
+function getStore() {
+  return new Conf({ projectName: "shed", defaults: DEFAULTS });
+}
+function flatGet(store, key) {
+  const def = KEY_DEFS[key];
+  if (!def) return void 0;
+  const saved = store.store;
+  const merged = {
+    scan: { ...DEFAULTS.scan, ...saved.scan ?? {} },
+    clean: { ...DEFAULTS.clean, ...saved.clean ?? {} },
+    ai: { ...DEFAULTS.ai, ...saved.ai ?? {} }
+  };
+  return def.get(merged);
+}
+function flatSet(store, key, raw) {
+  const parts = key.split(".");
+  if (parts.length !== 2) return false;
+  const [section, field] = parts;
+  const current = store.get(section);
+  if (typeof current !== "object" || current === null) return false;
+  const existing = current[field];
+  let parsed;
+  if (typeof existing === "boolean") {
+    if (raw === "true") parsed = true;
+    else if (raw === "false") parsed = false;
+    else return false;
+  } else if (typeof existing === "number") {
+    const n = Number(raw);
+    if (Number.isNaN(n)) return false;
+    parsed = n;
+  } else {
+    parsed = raw;
+  }
+  store.set(
+    section,
+    { ...current, [field]: parsed }
+  );
+  return true;
+}
+async function configCommand(action, key, value) {
+  p2.intro(pc2.bgBlue(pc2.black(" shed config ")));
+  const store = getStore();
+  switch (action) {
+    case "list":
+    case void 0: {
+      const lines = Object.entries(KEY_DEFS).map(([k, def]) => {
+        const val = flatGet(store, k);
+        const isDefault = String(val) === String(def.get(DEFAULTS));
+        const valStr = isDefault ? pc2.dim(String(val)) : pc2.cyan(String(val));
+        return `  ${k.padEnd(22)} ${valStr}${isDefault ? pc2.dim("  (default)") : ""}`;
+      });
+      p2.note(lines.join("\n"), "Current configuration");
+      p2.note(pc2.dim(store.path), "Config file");
+      break;
+    }
+    case "get": {
+      if (!key || !(key in KEY_DEFS)) {
+        p2.cancel(
+          !key ? "Usage: shed config get <key>" : `Unknown key: ${key}
+Valid: ${Object.keys(KEY_DEFS).join(", ")}`
+        );
+        process.exit(1);
+      }
+      console.log(flatGet(store, key));
+      break;
+    }
+    case "set": {
+      if (!key || value === void 0) {
+        p2.cancel("Usage: shed config set <key> <value>");
+        process.exit(1);
+      }
+      if (!(key in KEY_DEFS)) {
+        p2.cancel(`Unknown key: ${key}
+Valid: ${Object.keys(KEY_DEFS).join(", ")}`);
+        process.exit(1);
+      }
+      if (!flatSet(store, key, value)) {
+        p2.cancel(`Invalid value "${value}" for key "${key}"`);
+        process.exit(1);
+      }
+      p2.outro(`${pc2.cyan(key)} = ${pc2.green(value)}`);
+      return;
+    }
+    case "reset": {
+      if (key) {
+        if (!(key in KEY_DEFS)) {
+          p2.cancel(`Unknown key: ${key}`);
+          process.exit(1);
+        }
+        const [section] = key.split(".");
+        store.set(section, DEFAULTS[section]);
+        p2.outro(`${pc2.cyan(key)} reset to default.`);
+      } else {
+        const confirmed = await p2.confirm({
+          message: "Reset ALL settings to defaults?",
+          initialValue: false
+        });
+        if (p2.isCancel(confirmed) || !confirmed) {
+          p2.cancel("Cancelled.");
+          return;
+        }
+        store.clear();
+        p2.outro("All settings reset to defaults.");
+      }
+      return;
+    }
+    default:
+      p2.cancel(`Unknown action: ${action}
+Usage: shed config [list|get|set|reset]`);
+      process.exit(1);
+  }
+  p2.outro(pc2.dim(`Edit directly: ${store.path}`));
+}
+
+// src/commands/doctor.ts
+import { arch, homedir, platform, release } from "os";
+import * as p3 from "@clack/prompts";
+import { execa } from "execa";
+import pc3 from "picocolors";
+async function doctorCommand() {
+  p3.intro(pc3.bgGreen(pc3.black(" shed doctor ")));
+  const checks = [];
+  checks.push({ name: "OS", value: `${platform()} ${release()} (${arch()})` });
+  checks.push({ name: "Home", value: homedir() });
+  checks.push({ name: "Node", value: process.version });
+  const tools = ["git", "npm", "pnpm", "yarn", "docker"];
+  for (const tool of tools) {
+    try {
+      const { stdout } = await execa(tool, ["--version"], { reject: false });
+      checks.push({ name: tool, value: stdout.split("\n")[0] ?? "unknown" });
+    } catch {
+      checks.push({ name: tool, value: pc3.dim("not installed") });
+    }
+  }
+  const body = checks.map((c) => `  ${pc3.cyan(c.name.padEnd(10))} ${c.value}`).join("\n");
+  p3.note(body, "Environment");
+  p3.outro(pc3.green("Environment check complete."));
+}
+
+// src/commands/scan.ts
+import { resolve as resolve2 } from "path";
+import * as p4 from "@clack/prompts";
+import {
+  AndroidDetector as AndroidDetector2,
+  CocoaPodsDetector as CocoaPodsDetector2,
+  DatabaseDetector,
+  DockerDetector as DockerDetector2,
+  DotnetDetector,
+  FlutterDetector as FlutterDetector2,
+  GoDetector,
+  IdeDetector as IdeDetector2,
+  JavaGradleDetector,
+  JavaMavenDetector,
+  NodeDetector as NodeDetector2,
+  PythonDetector as PythonDetector2,
+  RiskTier as RiskTier2,
+  RubyDetector,
+  RustDetector as RustDetector2,
+  Scanner as Scanner2,
+  SystemDetector,
+  WebserverDetector,
+  XcodeDetector as XcodeDetector2
+} from "@lexmanh/shed-core";
+import pc4 from "picocolors";
+var RISK_LABEL = {
+  [RiskTier2.Green]: pc4.green("\u25CF Green"),
+  [RiskTier2.Yellow]: pc4.yellow("\u25CF Yellow"),
+  [RiskTier2.Red]: pc4.red("\u25CF Red")
+};
+var RISK_ORDER = {
+  [RiskTier2.Red]: 0,
+  [RiskTier2.Yellow]: 1,
+  [RiskTier2.Green]: 2
+};
+function formatBytes2(bytes) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+async function scanCommand(path = ".", options = {}) {
+  const rootDir = resolve2(path);
+  if (!options.json) {
+    p4.intro(pc4.bgCyan(pc4.black(" shed scan ")));
+  }
+  const spinner3 = options.json ? null : p4.spinner();
+  verbose(`scan root: ${rootDir}`);
+  spinner3?.start(`Scanning ${rootDir} \u2026`);
+  const scanner = new Scanner2([
+    new NodeDetector2(),
+    new PythonDetector2(),
+    new RustDetector2(),
+    new GoDetector(),
+    new JavaMavenDetector(),
+    new JavaGradleDetector(),
+    new RubyDetector(),
+    new DotnetDetector(),
+    new DockerDetector2(),
+    new XcodeDetector2(),
+    new FlutterDetector2(),
+    new AndroidDetector2(),
+    new CocoaPodsDetector2(),
+    new IdeDetector2(),
+    new SystemDetector(),
+    new WebserverDetector(),
+    new DatabaseDetector()
+  ]);
+  const ctx = { scanRoot: rootDir, maxDepth: 8 };
+  const [projects, globalItems] = await Promise.all([
+    scanner.scan(rootDir),
+    scanner.scanGlobal(ctx)
+  ]);
+  const allItems = [
+    ...projects.flatMap((proj) => proj.items),
+    ...globalItems
+  ].sort((a, b) => RISK_ORDER[a.risk] - RISK_ORDER[b.risk]);
+  const totalBytes = allItems.reduce((sum, i) => sum + i.sizeBytes, 0);
+  verbose(
+    `scan complete: ${projects.length} projects, ${globalItems.length} global items, ${allItems.length} total`
+  );
+  for (const item of allItems)
+    verbose(`  item: ${item.risk} ${item.path} (${item.sizeBytes} bytes)`);
+  spinner3?.stop(
+    `Found ${pc4.bold(String(allItems.length))} cleanable items across ${projects.length} project(s).`
+  );
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          root: rootDir,
+          projects: projects.length,
+          items: allItems,
+          totalBytes
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (allItems.length === 0) {
+    p4.note("Nothing found to clean in this directory.", "Result");
+    p4.outro(pc4.dim("All clear!"));
+    return;
+  }
+  const byProject = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    const key = item.projectRoot ?? "(global)";
+    const group = byProject.get(key) ?? [];
+    group.push(item);
+    byProject.set(key, group);
+  }
+  for (const [projectRoot, items] of byProject.entries()) {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const projectLabel = projectRoot === "(global)" ? pc4.dim("global caches") : pc4.cyan(home ? projectRoot.replace(home, "~") : projectRoot);
+    const groupTotal = items.reduce((s, i) => s + i.sizeBytes, 0);
+    console.log(`
+  ${projectLabel}  ${pc4.dim(formatBytes2(groupTotal))}`);
+    for (const item of items) {
+      const size = item.sizeBytes > 0 ? pc4.dim(` ${formatBytes2(item.sizeBytes)}`) : "";
+      const displayPath = home ? item.path.replace(home, "~") : item.path;
+      const shortPath = projectRoot !== "(global)" ? displayPath.replace(home ? projectRoot.replace(home, "~") : projectRoot, "").replace(/^\//, "") || displayPath : displayPath;
+      console.log(`    ${RISK_LABEL[item.risk]}  ${shortPath}${size}`);
+      console.log(`    ${pc4.dim(`       ${item.description}`)}`);
+    }
+  }
+  console.log();
+  p4.outro(
+    `Total recoverable: ${pc4.bold(pc4.green(formatBytes2(totalBytes)))} \u2014 run ${pc4.cyan("shed clean")} to proceed.`
+  );
+}
+
+// src/commands/undo.ts
+import { platform as platform2 } from "os";
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
+function trashPath() {
+  switch (platform2()) {
+    case "darwin":
+      return "~/.Trash";
+    case "win32":
+      return "Recycle Bin";
+    default:
+      return "~/.local/share/Trash";
+  }
+}
+function trashOpenHint() {
+  switch (platform2()) {
+    case "darwin":
+      return "open ~/.Trash  (or click Trash in Dock \u2192 right-click \u2192 Put Back)";
+    case "win32":
+      return "Open Recycle Bin on desktop \u2192 right-click item \u2192 Restore";
+    default:
+      return "nautilus trash:///  or  gio trash --list / gio trash --restore";
+  }
+}
+async function undoCommand() {
+  p5.intro(pc5.bgMagenta(pc5.black(" shed undo ")));
+  p5.note(
+    [
+      "shed clean moves items to your OS Trash by default.",
+      "",
+      `  Trash location: ${pc5.cyan(trashPath())}`,
+      "",
+      `  To restore: ${pc5.dim(trashOpenHint())}`,
+      "",
+      pc5.dim("Tip: shed clean --hard-delete bypasses Trash (no undo possible)."),
+      pc5.dim("     shed clean --dry-run to preview before any real deletion.")
+    ].join("\n"),
+    "How to undo a cleanup"
+  );
+  p5.outro(pc5.green("Nothing to do \u2014 restore items via your OS Trash."));
+}
+
+// src/logo.ts
+import pc6 from "picocolors";
+var ART = [
+  "  ____  _              _ ",
+  " / ___|| |__   ___  __| |",
+  " \\___ \\| '_ \\ / _ \\/ _` |",
+  "  ___) | | | |  __/ (_| |",
+  " |____/|_| |_|\\___|\\__,_|"
+].join("\n");
+function printLogo(version2) {
+  console.log(pc6.cyan(ART));
+  console.log(`  ${pc6.dim(`v${version2} \xB7 safe disk cleanup for developers`)}`);
+  console.log(
+    `  ${pc6.dim("by")} ${pc6.white("L\xEA Xu\xE2n M\u1EA1nh")} ${pc6.dim("\xB7 https://github.com/lexmanh/shed")}
+`
+  );
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("shed").description("Safe, cross-platform disk cleanup for developers").version(version).option("-v, --verbose", "Enable verbose logging");
+program.command("scan [path]").description("Scan for cleanable items without modifying anything").option("--json", "Output machine-readable JSON").option("--max-age <days>", "Only include items older than N days", "30").action(scanCommand);
+program.command("clean [path]").description("Interactive cleanup of detected items").option("--dry-run", "Preview operations without executing", true).option("--execute", "Actually perform the cleanup (overrides --dry-run)").option("--hard-delete", "Skip Trash, delete permanently").option("--include-red", "Include Red-tier (high-risk) items").option("--yes", "Skip interactive confirmations (CI mode)").action(cleanCommand);
+program.command("undo").description("List and restore items from previous cleanups").action(undoCommand);
+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.hook("preAction", (_thisCommand, actionCommand) => {
+  const opts = program.opts();
+  setVerbose(opts.verbose ?? false);
+  const cmdOpts = actionCommand.opts();
+  if (!cmdOpts.json) printLogo(version);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error("shed: fatal error:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@lexmanh/shed-cli",
+  "version": "0.2.0-beta.1",
+  "description": "Safe, cross-platform disk cleanup CLI for developers — reclaim space from dev caches without breaking active work",
+  "type": "module",
+  "bin": {
+    "shed": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "commander": "^12.1.0",
+    "conf": "^13.1.0",
+    "execa": "^9.5.0",
+    "picocolors": "^1.1.1",
+    "@lexmanh/shed-core": "0.2.0-beta.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts --format esm --clean",
+    "dev": "tsup src/cli.ts --format esm --watch",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}