d4c-pool 0.2.0

package/dist/index.js

@@ -0,0 +1,1432 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../core/src/reap/index.ts
+import { lstat as lstat2, stat as stat2, rm } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+
+// ../core/src/fs/trees.ts
+import { readdir, lstat, stat, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var LOCKFILES = [
+  "npm-shrinkwrap.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb"
+];
+var SKIP_DIRS = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  ".Trash",
+  "Library"
+]);
+var DAY_MS = 86400000;
+var ACTIVITY_FILES = [".git/index", ".git/HEAD", ".git/FETCH_HEAD"];
+async function lastActivityMs(projectRoot, nodeModulesMtimeMs) {
+  let latest = nodeModulesMtimeMs;
+  for (const rel of ACTIVITY_FILES) {
+    try {
+      const st = await lstat(join(projectRoot, rel));
+      if (st.mtimeMs > latest)
+        latest = st.mtimeMs;
+    } catch {}
+  }
+  return latest;
+}
+function globMatches(pattern, rel) {
+  let re = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i++;
+      } else
+        re += "[^/]*";
+      continue;
+    }
+    re += ch.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp("^" + re + "$").test(rel);
+}
+async function declaresWorkspaceMember(dir, projectRoot) {
+  const rel = projectRoot.slice(dir.length + 1);
+  if (rel === "" || rel.startsWith("/"))
+    return false;
+  const globs = [];
+  try {
+    const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+    const w = pkg.workspaces;
+    if (Array.isArray(w))
+      globs.push(...w);
+    else if (w && Array.isArray(w.packages))
+      globs.push(...w.packages);
+  } catch {}
+  try {
+    const yaml = await readFile(join(dir, "pnpm-workspace.yaml"), "utf8");
+    for (const line of yaml.split(`
+`)) {
+      const m = /^\s*-\s*['"]?([^'"#]+?)['"]?\s*$/.exec(line);
+      if (m)
+        globs.push(m[1].trim());
+    }
+  } catch {}
+  return globs.some((g) => globMatches(g, rel));
+}
+async function detectLockfile(projectRoot, scanRoot) {
+  for (const name of LOCKFILES) {
+    try {
+      const st = await lstat(join(projectRoot, name));
+      if (st.isFile())
+        return { lockfile: name, lockfileDir: projectRoot };
+    } catch {}
+  }
+  let dir = dirname(projectRoot);
+  for (;; ) {
+    if (!dir.startsWith(scanRoot))
+      break;
+    for (const name of LOCKFILES) {
+      try {
+        const st = await lstat(join(dir, name));
+        if (!st.isFile())
+          continue;
+        if (await declaresWorkspaceMember(dir, projectRoot)) {
+          return { lockfile: name, lockfileDir: dir };
+        }
+      } catch {}
+    }
+    if (dir === scanRoot)
+      break;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return { lockfile: null, lockfileDir: null };
+}
+function allocatedSize(st) {
+  return st.blocks * 512;
+}
+async function measureTree(tree, opts = {}) {
+  const m = await measure(tree.path, opts.statBatchSize ?? 256, opts.onUnreadable);
+  tree.sizeBytes = m.sizeBytes;
+  tree.externallyLinkedBytes = m.externallyLinkedBytes;
+  tree.fileCount = m.fileCount;
+  tree.crossesMountBoundary = m.crossesMountBoundary;
+  return tree;
+}
+async function measure(dir, batchSize, onUnreadable) {
+  let fileCount = 0;
+  let rootDev = null;
+  let crossesMountBoundary = false;
+  const inodes = new Map;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = await readdir(cur, { withFileTypes: true });
+    } catch {
+      onUnreadable?.(cur);
+      continue;
+    }
+    const files = [];
+    for (const e of entries) {
+      const p = join(cur, e.name);
+      if (e.isDirectory())
+        stack.push(p);
+      else if (e.isSymbolicLink())
+        fileCount++;
+      else if (e.isFile())
+        files.push(p);
+    }
+    for (let i = 0;i < files.length; i += batchSize) {
+      const stats = await Promise.all(files.slice(i, i + batchSize).map((f) => lstat(f).catch(() => null)));
+      for (const st of stats) {
+        if (st === null)
+          continue;
+        if (rootDev === null)
+          rootDev = st.dev;
+        else if (st.dev !== rootDev)
+          crossesMountBoundary = true;
+        fileCount++;
+        const key = `${st.dev}:${st.ino}`;
+        const seen = inodes.get(key);
+        if (seen === undefined)
+          inodes.set(key, { size: allocatedSize(st), nlink: st.nlink, seen: 1 });
+        else
+          seen.seen++;
+      }
+    }
+  }
+  let sizeBytes = 0;
+  let externallyLinkedBytes = 0;
+  for (const { size, nlink, seen } of inodes.values()) {
+    if (seen < nlink)
+      externallyLinkedBytes += size;
+    else
+      sizeBytes += size;
+  }
+  return { sizeBytes, externallyLinkedBytes, fileCount, crossesMountBoundary };
+}
+async function findDependencyTrees(root, opts = {}) {
+  const maxDepth = opts.maxDepth ?? 8;
+  const batchSize = opts.statBatchSize ?? 256;
+  const dirConcurrency = opts.dirConcurrency ?? 16;
+  const skip = new Set([...SKIP_DIRS, ...opts.skip ?? []]);
+  const out = [];
+  const now = Date.now();
+  const queue = [{ dir: root, depth: 0 }];
+  const visit = async (dir, depth) => {
+    if (depth > maxDepth) {
+      opts.onDepthLimit?.(dir);
+      return;
+    }
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      opts.onUnreadable?.(dir);
+      return;
+    }
+    const nm = entries.find((e) => e.name === "node_modules");
+    if (nm) {
+      const nmPath = join(dir, "node_modules");
+      if (nm.isDirectory() && !nm.isSymbolicLink()) {
+        try {
+          const st = await stat(nmPath);
+          const tree = {
+            path: nmPath,
+            projectRoot: dir,
+            sizeBytes: null,
+            externallyLinkedBytes: null,
+            fileCount: null,
+            crossesMountBoundary: false,
+            idleDays: Math.max(0, Math.floor((now - await lastActivityMs(dir, st.mtimeMs)) / DAY_MS)),
+            ...await detectLockfile(dir, root)
+          };
+          out.push(tree);
+          opts.onTree?.(tree);
+        } catch {}
+      }
+    }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.isSymbolicLink())
+        continue;
+      if (skip.has(e.name))
+        continue;
+      queue.push({ dir: join(dir, e.name), depth: depth + 1 });
+    }
+  };
+  let active = 0;
+  const workers = Array.from({ length: dirConcurrency }, async () => {
+    for (;; ) {
+      if (opts.signal?.aborted === true)
+        return;
+      const next = queue.pop();
+      if (next === undefined) {
+        if (active === 0)
+          return;
+        await new Promise((r) => setTimeout(r, 1));
+        continue;
+      }
+      active++;
+      try {
+        await visit(next.dir, next.depth);
+      } finally {
+        active--;
+      }
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+
+// ../core/src/reap/filter.ts
+function toRegExp(pattern) {
+  let out = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        out += ".*";
+        i++;
+      } else {
+        out += "[^/]*";
+      }
+      continue;
+    }
+    out += ch.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp("^" + out + "$");
+}
+function matchesAny(path, patterns) {
+  return patterns.some((p) => toRegExp(p).test(path));
+}
+var UNITS = {
+  "": 1,
+  b: 1,
+  k: 1024,
+  kb: 1024,
+  kib: 1024,
+  m: 1024 ** 2,
+  mb: 1024 ** 2,
+  mib: 1024 ** 2,
+  g: 1024 ** 3,
+  gb: 1024 ** 3,
+  gib: 1024 ** 3,
+  t: 1024 ** 4,
+  tb: 1024 ** 4,
+  tib: 1024 ** 4
+};
+function parseSize(input) {
+  const m = /^(\d+(?:\.\d+)?)\s*([a-zA-Z]*)$/.exec(input.trim());
+  if (m === null)
+    return null;
+  const unit = UNITS[m[2].toLowerCase()];
+  if (unit === undefined)
+    return null;
+  const n = Number(m[1]) * unit;
+  return Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
+}
+
+// ../core/src/reap/log.ts
+import { appendFile, mkdir, readFile as readFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2 } from "node:path";
+function defaultLogPath(env = process.env) {
+  const state = env.XDG_STATE_HOME ?? join2(env.HOME ?? ".", ".local", "state");
+  return join2(state, "d4c", "deletions.jsonl");
+}
+async function appendDeletion(logPath, input) {
+  const rec = {
+    at: new Date().toISOString(),
+    runId: input.runId,
+    root: input.root,
+    projectRoot: input.tree.projectRoot,
+    path: input.tree.path,
+    freedBytes: input.freedBytes,
+    idleDays: input.tree.idleDays,
+    lockfile: input.tree.lockfile,
+    lockfileDir: input.tree.lockfileDir
+  };
+  await mkdir(dirname2(logPath), { recursive: true });
+  await appendFile(logPath, JSON.stringify(rec) + `
+`, "utf8");
+}
+async function readHistory(logPath) {
+  let raw;
+  try {
+    raw = await readFile2(logPath, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const v = JSON.parse(line);
+      if (typeof v.projectRoot === "string")
+        out.push(v);
+    } catch {}
+  }
+  return out;
+}
+function restoreCommand(lockfile) {
+  switch (lockfile) {
+    case "yarn.lock":
+      return "yarn install";
+    case "pnpm-lock.yaml":
+      return "pnpm install";
+    case "bun.lock":
+    case "bun.lockb":
+      return "bun install";
+    default:
+      return "npm install";
+  }
+}
+
+// ../core/src/reap/index.ts
+function relativeTo(path, root) {
+  if (path === root)
+    return ".";
+  const prefix = root.endsWith("/") ? root : root + "/";
+  return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+var DEFAULT_IDLE_THRESHOLD_DAYS = 30;
+async function planReap(root, opts = {}) {
+  const idleThresholdDays = opts.idleThresholdDays ?? DEFAULT_IDLE_THRESHOLD_DAYS;
+  if (idleThresholdDays < 1) {
+    throw new RangeError("idleThresholdDays must be at least 1");
+  }
+  const diagnostics = { unreadableDirs: 0, depthLimited: 0 };
+  const trees = await findDependencyTrees(root, {
+    ...opts,
+    signal: opts.signal,
+    onUnreadable: (p) => {
+      diagnostics.unreadableDirs++;
+      opts.onUnreadable?.(p);
+    },
+    onDepthLimit: (p) => {
+      diagnostics.depthLimited++;
+      opts.onDepthLimit?.(p);
+    }
+  });
+  const candidates = [];
+  const skipped = [];
+  let totalBytes = 0;
+  const exclude = opts.exclude ?? [];
+  const minSizeBytes = opts.minSizeBytes ?? 0;
+  for (const tree of trees) {
+    if (matchesAny(relativeTo(tree.projectRoot, root), exclude)) {
+      skipped.push({ tree, reason: "excluded" });
+      continue;
+    }
+    if (tree.idleDays < idleThresholdDays) {
+      skipped.push({ tree, reason: "recently-modified" });
+      continue;
+    }
+    if (tree.lockfile === null) {
+      skipped.push({ tree, reason: "no-lockfile" });
+      continue;
+    }
+    let plannedMtimeMs = 0;
+    try {
+      plannedMtimeMs = (await lstat2(tree.path)).mtimeMs;
+    } catch {
+      continue;
+    }
+    candidates.push({ tree, plannedMtimeMs });
+  }
+  let interrupted = opts.signal?.aborted === true;
+  for (const c of candidates) {
+    if (opts.signal?.aborted === true) {
+      interrupted = true;
+      break;
+    }
+    await measureTree(c.tree, { statBatchSize: opts.statBatchSize, onUnreadable: opts.onUnreadable });
+    totalBytes += c.tree.sizeBytes ?? 0;
+    opts.onMeasured?.(c.tree);
+  }
+  const tooSmall = candidates.filter((c) => (c.tree.sizeBytes ?? 0) < minSizeBytes);
+  for (const c of tooSmall)
+    skipped.push({ tree: c.tree, reason: "below-min-size" });
+  const kept = candidates.filter((c) => (c.tree.sizeBytes ?? 0) >= minSizeBytes);
+  candidates.length = 0;
+  candidates.push(...kept);
+  candidates.sort((a, b) => (b.tree.sizeBytes ?? 0) - (a.tree.sizeBytes ?? 0));
+  return {
+    root,
+    idleThresholdDays,
+    exclude,
+    minSizeBytes,
+    candidates,
+    skipped,
+    reclaimableBytes: candidates.reduce((s, c) => s + (c.tree.sizeBytes ?? 0), 0),
+    totalBytes,
+    treeCount: trees.length,
+    diagnostics,
+    interrupted
+  };
+}
+async function verifyStillReapable(c) {
+  const { tree, plannedMtimeMs } = c;
+  if (basename(tree.path) !== "node_modules")
+    return "not-a-node-modules-path";
+  let st;
+  try {
+    st = await lstat2(tree.path);
+  } catch {
+    return "vanished";
+  }
+  if (st.isSymbolicLink())
+    return "became-symlink";
+  if (!st.isDirectory())
+    return "not-a-node-modules-path";
+  if (st.mtimeMs !== plannedMtimeMs)
+    return "changed-since-plan";
+  if (c.tree.crossesMountBoundary)
+    return "crosses-mount-boundary";
+  if (tree.lockfile === null || tree.lockfileDir === null)
+    return "lockfile-vanished";
+  for (const f of [tree.lockfile, "package.json"]) {
+    try {
+      const st2 = await stat2(join3(tree.lockfileDir, f));
+      if (!st2.isFile())
+        return "lockfile-vanished";
+    } catch {
+      return "lockfile-vanished";
+    }
+  }
+  return null;
+}
+async function executeReap(plan, opts = {}) {
+  const apply = opts.apply === true;
+  const runId = opts.runId ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const logPath = !apply ? null : opts.logPath === null ? null : opts.logPath ?? defaultLogPath();
+  const deleted = [];
+  const aborted = [];
+  let interrupted = false;
+  for (const c of plan.candidates) {
+    if (opts.signal?.aborted === true) {
+      interrupted = true;
+      break;
+    }
+    const problem = await verifyStillReapable(c);
+    if (problem !== null) {
+      aborted.push({ tree: c.tree, reason: problem });
+      opts.onProgress?.(c.tree, "aborted");
+      continue;
+    }
+    if (!apply)
+      continue;
+    try {
+      await rm(c.tree.path, { recursive: true, force: false });
+      const freedBytes = c.tree.sizeBytes ?? 0;
+      deleted.push({ tree: c.tree, freedBytes });
+      if (logPath !== null) {
+        try {
+          await appendDeletion(logPath, { tree: c.tree, freedBytes, runId, root: plan.root });
+        } catch {}
+      }
+      opts.onProgress?.(c.tree, "deleted");
+    } catch (e) {
+      aborted.push({ tree: c.tree, reason: "delete-failed", detail: String(e) });
+      opts.onProgress?.(c.tree, "aborted");
+    }
+  }
+  return {
+    dryRun: !apply,
+    deleted,
+    aborted,
+    freedBytes: deleted.reduce((s, d) => s + d.freedBytes, 0),
+    interrupted,
+    runId,
+    logPath
+  };
+}
+
+// src/render.ts
+function humanBytes(n) {
+  const u = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let v = n, i = 0;
+  while (v >= 1024 && i < u.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v < 10 && i > 0 ? v.toFixed(1) : Math.round(v)} ${u[i]}`;
+}
+function relativize(path, root) {
+  return path.startsWith(root) ? "." + path.slice(root.length) : path;
+}
+
+// src/commands/gc.ts
+async function gc(args) {
+  const showProgress = process.stderr.isTTY === true;
+  let found = 0;
+  let measured = 0;
+  let measuredBytes = 0;
+  let lastDraw = 0;
+  const draw = (line) => {
+    const now = Date.now();
+    if (now - lastDraw < 100)
+      return;
+    lastDraw = now;
+    process.stderr.write(`\r${line.padEnd(60)}`);
+  };
+  const onTree = showProgress ? () => {
+    found++;
+    draw(`  finding trees… ${found}`);
+  } : undefined;
+  const onMeasured = showProgress ? (t) => {
+    measured++;
+    measuredBytes += t.sizeBytes ?? 0;
+    draw(`  measuring… ${measured} candidate(s), ${humanBytes(measuredBytes)}`);
+  } : undefined;
+  const ac = new AbortController;
+  let interrupts = 0;
+  const onSigint = () => {
+    interrupts++;
+    if (interrupts === 1) {
+      ac.abort();
+      process.stderr.write(`
+  stopping after the current tree… (Ctrl+C again to force)
+`);
+    } else {
+      process.exit(130);
+    }
+  };
+  process.on("SIGINT", onSigint);
+  const plan = await planReap(args.cwd, {
+    idleThresholdDays: args.days,
+    maxDepth: args.depth,
+    signal: ac.signal,
+    exclude: args.exclude,
+    minSizeBytes: args.minSizeBytes,
+    onTree,
+    onMeasured
+  });
+  if (showProgress)
+    process.stderr.write("\r" + " ".repeat(62) + "\r");
+  const result = await executeReap(plan, { apply: args.yes, logPath: args.logPath, signal: ac.signal });
+  process.off("SIGINT", onSigint);
+  if (args.json) {
+    process.stdout.write(JSON.stringify({
+      schemaVersion: 1,
+      root: args.cwd,
+      idleThresholdDays: plan.idleThresholdDays,
+      exclude: plan.exclude,
+      minSizeBytes: plan.minSizeBytes,
+      dryRun: result.dryRun,
+      interrupted: plan.interrupted || result.interrupted,
+      totalBytes: plan.totalBytes,
+      treeCount: plan.treeCount,
+      diagnostics: plan.diagnostics,
+      reclaimableBytes: plan.reclaimableBytes,
+      freedBytes: result.freedBytes,
+      candidates: plan.candidates.map((c) => ({
+        path: c.tree.path,
+        projectRoot: c.tree.projectRoot,
+        sizeBytes: c.tree.sizeBytes ?? 0,
+        externallyLinkedBytes: c.tree.externallyLinkedBytes ?? 0,
+        idleDays: c.tree.idleDays,
+        lockfile: c.tree.lockfile
+      })),
+      skipped: plan.skipped.map((s) => ({
+        projectRoot: s.tree.projectRoot,
+        sizeBytes: s.tree.sizeBytes,
+        idleDays: s.tree.idleDays,
+        reason: s.reason
+      })),
+      runId: result.runId,
+      logPath: result.logPath,
+      deleted: result.deleted.map((d2) => ({ path: d2.tree.path, freedBytes: d2.freedBytes })),
+      aborted: result.aborted.map((a) => ({ path: a.tree.path, reason: a.reason }))
+    }) + `
+`);
+    return 0;
+  }
+  const out = [];
+  out.push("D4C — dependency garbage collection", "");
+  if (plan.candidates.length === 0) {
+    out.push(`Nothing to reclaim. Scanned ${plan.treeCount} tree(s);`);
+    out.push(`none has been untouched for ${plan.idleThresholdDays}+ days with a lockfile present.`);
+    const noLock = plan.skipped.filter((s) => s.reason === "no-lockfile");
+    if (noLock.length > 0) {
+      out.push("", `${noLock.length} idle tree(s) skipped: no lockfile, so they could not be regenerated.`);
+    }
+    process.stdout.write(out.join(`
+`) + `
+`);
+    return 0;
+  }
+  const verb = result.dryRun ? "Would reclaim" : "Reclaimed";
+  const bytes = result.dryRun ? plan.reclaimableBytes : result.freedBytes;
+  out.push(`${verb} ${humanBytes(bytes)} from ${plan.candidates.length} tree(s)`);
+  out.push(`untouched for ${plan.idleThresholdDays}+ days, from ${plan.treeCount} tree(s) scanned.`, "");
+  for (const c of plan.candidates.slice(0, 20)) {
+    out.push(`  ${humanBytes(c.tree.sizeBytes ?? 0).padStart(9)}  ${String(c.tree.idleDays).padStart(4)}d  ${relativize(c.tree.projectRoot, args.cwd)}`);
+  }
+  if (plan.candidates.length > 20)
+    out.push(`  ... and ${plan.candidates.length - 20} more`);
+  if (result.aborted.length > 0) {
+    out.push("", `${result.aborted.length} skipped at the last check:`);
+    for (const a of result.aborted.slice(0, 10)) {
+      out.push(`  ${a.reason.padEnd(24)} ${relativize(a.tree.projectRoot, args.cwd)}`);
+    }
+  }
+  const externallyLinked = plan.candidates.reduce((n, c) => n + (c.tree.externallyLinkedBytes ?? 0), 0);
+  if (externallyLinked > 0) {
+    out.push("", `${humanBytes(externallyLinked)} in these trees is hardlinked from outside`);
+    out.push("and will not be freed by deleting them. It is excluded from the total above.");
+  }
+  const excluded = plan.skipped.filter((s) => s.reason === "excluded");
+  if (excluded.length > 0) {
+    out.push("", `${excluded.length} tree(s) protected by --exclude.`);
+  }
+  const d = plan.diagnostics;
+  if (d.unreadableDirs > 0 || d.depthLimited > 0) {
+    out.push("");
+    if (d.unreadableDirs > 0) {
+      out.push(`${d.unreadableDirs} director${d.unreadableDirs === 1 ? "y" : "ies"} could not be read;`);
+      out.push("trees inside them are missing from these totals.");
+    }
+    if (d.depthLimited > 0) {
+      out.push(`${d.depthLimited} path(s) hit the depth limit and were not searched further.`);
+    }
+  }
+  if (plan.interrupted || result.interrupted) {
+    out.push("");
+    out.push("Interrupted. The trees listed above are what was handled before stopping;");
+    out.push("anything else was left untouched.");
+  }
+  out.push("");
+  out.push("Idle age is measured from the last install or modification, not the");
+  out.push("last time the tree was read. A project you still use can look idle.");
+  out.push("");
+  out.push("Restore any of these by running `npm install` in the project.");
+  if (result.logPath !== null && result.deleted.length > 0) {
+    out.push(`Recorded in ${result.logPath} — see \`d4c history\`.`);
+  }
+  if (result.dryRun)
+    out.push("", "Nothing was deleted. Re-run with --yes to apply.");
+  process.stdout.write(out.join(`
+`) + `
+`);
+  return plan.interrupted || result.interrupted ? 130 : 0;
+}
+var DEFAULT_DAYS = DEFAULT_IDLE_THRESHOLD_DAYS;
+
+// ../core/src/dedupe/index.ts
+import { lstat as lstat5, mkdir as mkdir2, appendFile as appendFile2, realpath as realpath2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+
+// ../core/src/dedupe/index-builder.ts
+import { readdir as readdir2, lstat as lstat3, open } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { createHash } from "node:crypto";
+var DEFAULT_MIN_FILE_BYTES = 65536;
+async function hashFile(path) {
+  const fh = await open(path, "r");
+  try {
+    const h = createHash("sha512");
+    const buf = Buffer.allocUnsafe(1 << 20);
+    for (;; ) {
+      const { bytesRead } = await fh.read(buf, 0, buf.length, null);
+      if (bytesRead === 0)
+        break;
+      h.update(buf.subarray(0, bytesRead));
+    }
+    return h.digest("hex");
+  } finally {
+    await fh.close();
+  }
+}
+async function buildDuplicateIndex(treeRoots, opts = {}) {
+  const minFileBytes = opts.minFileBytes ?? DEFAULT_MIN_FILE_BYTES;
+  const byHash = new Map;
+  const seenInodes = new Set;
+  let hashed = 0;
+  let bytes = 0;
+  for (const root of treeRoots) {
+    const stack = [root];
+    while (stack.length > 0) {
+      if (opts.signal?.aborted === true)
+        return [];
+      const dir = stack.pop();
+      let entries;
+      try {
+        entries = await readdir2(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        const p = join4(dir, e.name);
+        if (e.isDirectory()) {
+          stack.push(p);
+          continue;
+        }
+        if (!e.isFile() || e.isSymbolicLink())
+          continue;
+        let st;
+        try {
+          st = await lstat3(p);
+        } catch {
+          continue;
+        }
+        if (st.size < minFileBytes)
+          continue;
+        if (st.nlink > 1)
+          continue;
+        const key = `${st.dev}:${st.ino}`;
+        if (seenInodes.has(key))
+          continue;
+        seenInodes.add(key);
+        let hash;
+        try {
+          hash = await hashFile(p);
+        } catch {
+          continue;
+        }
+        hashed++;
+        bytes += st.blocks * 512;
+        opts.onProgress?.(hashed, bytes);
+        const entry = {
+          path: p,
+          treeRoot: root,
+          sizeBytes: st.blocks * 512,
+          logicalSize: st.size,
+          hash,
+          dev: st.dev,
+          ino: st.ino,
+          mode: st.mode & 4095,
+          mtimeMs: st.mtimeMs,
+          cloneRefs: 0
+        };
+        const list = byHash.get(hash) ?? [];
+        list.push(entry);
+        byHash.set(hash, list);
+      }
+    }
+  }
+  const groups = [];
+  for (const [hash, all] of byHash) {
+    const byMode = new Map;
+    for (const f of all) {
+      const l = byMode.get(f.mode) ?? [];
+      l.push(f);
+      byMode.set(f.mode, l);
+    }
+    for (const files of byMode.values()) {
+      if (files.length < 2)
+        continue;
+      const byDev = new Map;
+      for (const f of files) {
+        const l = byDev.get(f.dev) ?? [];
+        l.push(f);
+        byDev.set(f.dev, l);
+      }
+      for (const same of byDev.values()) {
+        if (same.length < 2)
+          continue;
+        const canonical = pickCanonical(same);
+        const reclaimableBytes = same.filter((f) => f !== canonical).reduce((s, f) => s + f.sizeBytes, 0);
+        groups.push({ hash, files: same, canonical, reclaimableBytes });
+      }
+    }
+  }
+  groups.sort((a, b) => b.reclaimableBytes - a.reclaimableBytes);
+  return groups;
+}
+function pickCanonical(files) {
+  return files.reduce((best, f) => f.cloneRefs > best.cloneRefs ? f : best, files[0]);
+}
+
+// ../core/src/dedupe/replace.ts
+import { lstat as lstat4, open as open2, rm as rm2, rename, chmod, utimes } from "node:fs/promises";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { randomBytes } from "node:crypto";
+
+// ../core/src/clone/clonefile.ts
+var cachedFn;
+function loadClonefile() {
+  if (cachedFn !== undefined)
+    return cachedFn;
+  if (process.platform !== "darwin") {
+    cachedFn = null;
+    return null;
+  }
+  try {
+    const koffi = __require("koffi");
+    const lib = koffi.load("libSystem.B.dylib");
+    cachedFn = lib.func("int clonefile(const char *src, const char *dst, uint32_t flags)");
+  } catch {
+    cachedFn = null;
+  }
+  return cachedFn;
+}
+
+class CloneUnsupportedError extends Error {
+}
+
+class CloneFailedError extends Error {
+}
+async function cloneFile(src, dst) {
+  const fn = loadClonefile();
+  if (fn === null) {
+    throw new CloneUnsupportedError("clonefile is not available on this platform");
+  }
+  const rc = fn(src, dst, 0);
+  if (rc !== 0) {
+    throw new CloneFailedError(`clonefile failed: ${src} -> ${dst}`);
+  }
+}
+
+// ../core/src/dedupe/replace.ts
+async function sameContent(a, b) {
+  const [fa, fb] = await Promise.all([open2(a, "r"), open2(b, "r")]);
+  try {
+    const [sa, sb] = await Promise.all([fa.stat(), fb.stat()]);
+    if (sa.size !== sb.size)
+      return false;
+    const ba = Buffer.allocUnsafe(1 << 20);
+    const bb = Buffer.allocUnsafe(1 << 20);
+    for (;; ) {
+      const [ra, rb] = await Promise.all([
+        fa.read(ba, 0, ba.length, null),
+        fb.read(bb, 0, bb.length, null)
+      ]);
+      if (ra.bytesRead !== rb.bytesRead)
+        return false;
+      if (ra.bytesRead === 0)
+        return true;
+      if (!ba.subarray(0, ra.bytesRead).equals(bb.subarray(0, rb.bytesRead)))
+        return false;
+    }
+  } finally {
+    await Promise.all([fa.close(), fb.close()]);
+  }
+}
+async function replaceWithClone(canonical, target) {
+  let cs, ts;
+  try {
+    cs = await lstat4(canonical.path);
+  } catch {
+    return { ok: false, reason: "source-vanished" };
+  }
+  try {
+    ts = await lstat4(target.path);
+  } catch {
+    return { ok: false, reason: "target-vanished" };
+  }
+  if (ts.mtimeMs !== target.mtimeMs || ts.ino !== target.ino || ts.size !== target.logicalSize) {
+    return { ok: false, reason: "changed-since-index" };
+  }
+  if (cs.mtimeMs !== canonical.mtimeMs || cs.ino !== canonical.ino || cs.size !== canonical.logicalSize) {
+    return { ok: false, reason: "changed-since-index" };
+  }
+  if ((cs.mode & 4095) !== (ts.mode & 4095)) {
+    return { ok: false, reason: "changed-since-index" };
+  }
+  if (!await sameContent(canonical.path, target.path)) {
+    return { ok: false, reason: "content-changed" };
+  }
+  const tmp = join5(dirname3(target.path), `.d4c-tmp-${randomBytes(6).toString("hex")}`);
+  try {
+    await cloneFile(canonical.path, tmp);
+  } catch (e) {
+    await rm2(tmp, { force: true });
+    return { ok: false, reason: "clone-failed", detail: String(e) };
+  }
+  try {
+    await chmod(tmp, ts.mode & 4095);
+    await utimes(tmp, ts.atime, ts.mtime);
+    await rename(tmp, target.path);
+  } catch (e) {
+    await rm2(tmp, { force: true });
+    return { ok: false, reason: "clone-failed", detail: String(e) };
+  }
+  try {
+    if (!await sameContent(canonical.path, target.path)) {
+      return { ok: false, reason: "verify-failed" };
+    }
+  } catch {
+    return { ok: false, reason: "verify-failed" };
+  }
+  return { ok: true, freedBytes: target.sizeBytes };
+}
+
+// ../core/src/dedupe/open-files.ts
+import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+async function openFilesUnder(roots, opts = {}) {
+  if (roots.length === 0)
+    return new Set;
+  const bin = opts.lsofPath ?? "lsof";
+  const realRoots = await Promise.all(roots.map((r) => realpath(r).catch(() => r)));
+  return new Promise((resolve) => {
+    execFile(bin, ["-Fn", "-w"], { maxBuffer: 64 * 1024 * 1024, timeout: opts.timeoutMs ?? 60000 }, (err, stdout) => {
+      if (stdout === undefined || stdout === "") {
+        resolve(err ? null : new Set);
+        return;
+      }
+      const held = new Set;
+      for (const line of stdout.split(`
+`)) {
+        if (line.charCodeAt(0) !== 110)
+          continue;
+        const p = line.slice(1);
+        for (const root of realRoots) {
+          if (p.startsWith(root)) {
+            held.add(p);
+            break;
+          }
+        }
+      }
+      resolve(held);
+    });
+  });
+}
+
+// ../core/src/dedupe/index.ts
+var DEFAULT_IDLE_THRESHOLD_DAYS2 = 30;
+async function planDedupe(inputRoot, opts = {}) {
+  const idleThresholdDays = opts.idleThresholdDays ?? DEFAULT_IDLE_THRESHOLD_DAYS2;
+  if (idleThresholdDays < 1)
+    throw new RangeError("idleThresholdDays must be at least 1");
+  const root = await realpath2(inputRoot).catch(() => inputRoot);
+  const all = await findDependencyTrees(root, opts);
+  const exclude = opts.exclude ?? [];
+  const trees = all.filter((t) => t.idleDays >= idleThresholdDays && !matchesAny(relativeTo2(t.projectRoot, root), exclude));
+  const treeMtimes = {};
+  for (const t of trees) {
+    try {
+      treeMtimes[t.path] = (await lstat5(t.path)).mtimeMs;
+    } catch {}
+  }
+  const empty = (check2) => ({
+    root,
+    idleThresholdDays,
+    trees,
+    groups: [],
+    reclaimableBytes: 0,
+    openFileCheck: check2,
+    excludedOpenFiles: 0,
+    treeMtimes,
+    interrupted: false
+  });
+  if (trees.length === 0)
+    return empty(opts.skipOpenFileCheck === true ? "skipped" : "clean");
+  let held = new Set;
+  let check = "skipped";
+  if (opts.skipOpenFileCheck !== true) {
+    held = await openFilesUnder(trees.map((t) => t.path), { lsofPath: opts.lsofPath });
+    if (held === null)
+      return empty("unavailable");
+    check = "clean";
+  }
+  const groups = await buildDuplicateIndex(trees.map((t) => t.path), {
+    minFileBytes: opts.minFileBytes,
+    onProgress: opts.onProgress,
+    signal: opts.signal
+  });
+  let excludedOpenFiles = 0;
+  const filtered = [];
+  for (const g of groups) {
+    const files = g.files.filter((f) => {
+      if (held !== null && held.has(f.path)) {
+        excludedOpenFiles++;
+        return false;
+      }
+      return true;
+    });
+    if (files.length < 2)
+      continue;
+    const canonical = files.includes(g.canonical) ? g.canonical : files[0];
+    filtered.push({
+      hash: g.hash,
+      files,
+      canonical,
+      reclaimableBytes: files.filter((f) => f !== canonical).reduce((s, f) => s + f.sizeBytes, 0)
+    });
+  }
+  return {
+    root,
+    idleThresholdDays,
+    trees,
+    groups: filtered,
+    reclaimableBytes: filtered.reduce((s, g) => s + g.reclaimableBytes, 0),
+    openFileCheck: check,
+    excludedOpenFiles,
+    treeMtimes,
+    interrupted: opts.signal?.aborted === true
+  };
+}
+function relativeTo2(path, root) {
+  if (path === root)
+    return ".";
+  const prefix = root.endsWith("/") ? root : root + "/";
+  return path.startsWith(prefix) ? path.slice(prefix.length) : path;
+}
+async function executeDedupe(plan, opts = {}) {
+  const apply = opts.apply === true;
+  const runId = opts.runId ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const logPath = !apply ? null : opts.logPath === null ? null : opts.logPath ?? defaultLogPath();
+  const failures = [];
+  const abortedTrees = [];
+  const abandoned = new Set;
+  let replaced = 0;
+  let freedBytes = 0;
+  let interrupted = false;
+  const treeMtime = new Map(Object.entries(plan.treeMtimes));
+  outer:
+    for (const g of plan.groups) {
+      for (const target of g.files) {
+        if (target === g.canonical)
+          continue;
+        if (opts.signal?.aborted === true) {
+          interrupted = true;
+          break outer;
+        }
+        if (abandoned.has(target.treeRoot))
+          continue;
+        const planned = treeMtime.get(target.treeRoot);
+        if (planned !== undefined) {
+          let now;
+          try {
+            now = (await lstat5(target.treeRoot)).mtimeMs;
+          } catch {
+            now = -1;
+          }
+          if (now !== planned) {
+            abandoned.add(target.treeRoot);
+            abortedTrees.push(target.treeRoot);
+            continue;
+          }
+        }
+        if (!apply)
+          continue;
+        const r = await replaceWithClone(g.canonical, target);
+        if (!r.ok) {
+          failures.push({ path: target.path, reason: r.reason });
+          continue;
+        }
+        replaced++;
+        freedBytes += r.freedBytes;
+        if (logPath !== null) {
+          try {
+            await mkdir2(dirname4(logPath), { recursive: true });
+            await appendFile2(logPath, JSON.stringify({
+              event: "dedupe",
+              at: new Date().toISOString(),
+              runId,
+              root: plan.root,
+              path: target.path,
+              canonical: g.canonical.path,
+              freedBytes: r.freedBytes,
+              hash: g.hash
+            }) + `
+`, "utf8");
+          } catch {}
+        }
+        opts.onReplaced?.(target, r.freedBytes);
+      }
+    }
+  return { dryRun: !apply, replaced, freedBytes, failures, abortedTrees, interrupted, runId, logPath };
+}
+
+// src/commands/dedupe.ts
+async function dedupe(args) {
+  const showProgress = process.stderr.isTTY === true;
+  let lastDraw = 0;
+  const ac = new AbortController;
+  let interrupts = 0;
+  const onSigint = () => {
+    if (++interrupts === 1) {
+      ac.abort();
+      process.stderr.write(`
+  stopping after the current file…
+`);
+    } else
+      process.exit(130);
+  };
+  process.on("SIGINT", onSigint);
+  const plan = await planDedupe(args.cwd, {
+    idleThresholdDays: args.days,
+    exclude: args.exclude,
+    minFileBytes: args.minFileBytes,
+    skipOpenFileCheck: args.skipOpenCheck,
+    lsofPath: args.lsofPath,
+    maxDepth: args.depth,
+    signal: ac.signal,
+    onProgress: showProgress ? (n, b) => {
+      const now = Date.now();
+      if (now - lastDraw < 120)
+        return;
+      lastDraw = now;
+      process.stderr.write(`\r  hashing… ${n} files, ${humanBytes(b)}`.padEnd(60));
+    } : undefined
+  });
+  if (showProgress)
+    process.stderr.write("\r" + " ".repeat(62) + "\r");
+  const result = await executeDedupe(plan, {
+    apply: args.yes,
+    logPath: args.logPath,
+    signal: ac.signal
+  });
+  process.off("SIGINT", onSigint);
+  if (args.json) {
+    process.stdout.write(JSON.stringify({
+      schemaVersion: 1,
+      root: plan.root,
+      idleThresholdDays: plan.idleThresholdDays,
+      dryRun: result.dryRun,
+      interrupted: plan.interrupted || result.interrupted,
+      openFileCheck: plan.openFileCheck,
+      excludedOpenFiles: plan.excludedOpenFiles,
+      treeCount: plan.trees.length,
+      groupCount: plan.groups.length,
+      reclaimableBytes: plan.reclaimableBytes,
+      freedBytes: result.freedBytes,
+      replaced: result.replaced,
+      runId: result.runId,
+      logPath: result.logPath,
+      failures: result.failures,
+      abortedTrees: result.abortedTrees,
+      groups: plan.groups.slice(0, 200).map((g) => ({
+        copies: g.files.length,
+        reclaimableBytes: g.reclaimableBytes,
+        canonical: g.canonical.path
+      }))
+    }) + `
+`);
+    return 0;
+  }
+  const out = ["D4C — deduplicate identical dependency files", ""];
+  if (plan.openFileCheck === "unavailable") {
+    out.push("Could not run lsof, so it is unknown whether anything has these files open.");
+    out.push("Replacing a file a process is writing to would lose that write silently,");
+    out.push("so nothing was examined. Install lsof, or pass --skip-open-check to");
+    out.push("proceed without it.");
+    process.stdout.write(out.join(`
+`) + `
+`);
+    return 0;
+  }
+  if (plan.groups.length === 0) {
+    out.push(`Nothing to deduplicate across ${plan.trees.length} tree(s)`);
+    out.push(`untouched for ${plan.idleThresholdDays}+ days.`);
+    if (plan.excludedOpenFiles > 0) {
+      out.push("", `${plan.excludedOpenFiles} file(s) were skipped because a process has them open.`);
+    }
+    process.stdout.write(out.join(`
+`) + `
+`);
+    return 0;
+  }
+  const verb = result.dryRun ? "Would reclaim" : "Reclaimed";
+  const bytes = result.dryRun ? plan.reclaimableBytes : result.freedBytes;
+  out.push(`${verb} ${humanBytes(bytes)} from ${plan.groups.length} duplicated file(s)`);
+  out.push(`across ${plan.trees.length} tree(s) untouched for ${plan.idleThresholdDays}+ days.`, "");
+  for (const g of plan.groups.slice(0, 15)) {
+    const name = g.canonical.path.split("/node_modules/")[1] ?? relativize(g.canonical.path, plan.root);
+    out.push(`  ${humanBytes(g.reclaimableBytes).padStart(9)}  ${String(g.files.length).padStart(3)} copies  ${name.slice(0, 52)}`);
+  }
+  if (plan.groups.length > 15)
+    out.push(`  ... and ${plan.groups.length - 15} more`);
+  if (plan.excludedOpenFiles > 0) {
+    out.push("", `${plan.excludedOpenFiles} file(s) skipped — a process has them open.`);
+  }
+  if (result.abortedTrees.length > 0) {
+    out.push("", `${result.abortedTrees.length} tree(s) changed while running and were left alone.`);
+  }
+  if (result.failures.length > 0) {
+    out.push("", `${result.failures.length} file(s) failed a check and were not touched.`);
+  }
+  out.push("");
+  out.push("Nothing is deleted. Each copy stays where it is and keeps working —");
+  out.push("they just share storage until one of them is written to.");
+  if (result.logPath !== null && result.replaced > 0) {
+    out.push(`Recorded in ${result.logPath}.`);
+  }
+  if (result.dryRun)
+    out.push("", "Nothing was changed. Re-run with --yes to apply.");
+  process.stdout.write(out.join(`
+`) + `
+`);
+  return plan.interrupted || result.interrupted ? 130 : 0;
+}
+var DEDUPE_DEFAULT_DAYS = DEFAULT_IDLE_THRESHOLD_DAYS2;
+
+// src/commands/history.ts
+function groupByRun(records) {
+  const runs = new Map;
+  for (const r of records) {
+    const list = runs.get(r.runId) ?? [];
+    list.push(r);
+    runs.set(r.runId, list);
+  }
+  return runs;
+}
+async function history(args) {
+  const path = args.logPath ?? defaultLogPath();
+  const records = await readHistory(path);
+  if (args.json) {
+    process.stdout.write(JSON.stringify({ schemaVersion: 1, logPath: path, records }) + `
+`);
+    return 0;
+  }
+  if (records.length === 0) {
+    process.stdout.write(`No deletions recorded.
+Log would be at ${path}
+`);
+    return 0;
+  }
+  const runs = [...groupByRun(records).entries()].reverse().slice(0, args.limit);
+  const out = [`D4C — deletion history (${path})`, ""];
+  for (const [runId, recs] of runs) {
+    const freed = recs.reduce((s, r) => s + r.freedBytes, 0);
+    out.push(`${recs[0].at}  run ${runId}`);
+    out.push(`  ${recs.length} tree(s), ${humanBytes(freed)} freed, scanned from ${recs[0].root}`);
+    for (const r of recs.slice(0, 10)) {
+      out.push(`    ${humanBytes(r.freedBytes).padStart(9)}  ${r.projectRoot}`);
+    }
+    if (recs.length > 10)
+      out.push(`    ... and ${recs.length - 10} more`);
+    out.push("");
+  }
+  const cmds = new Set(records.map((r) => restoreCommand(r.lockfile)));
+  out.push("Restore any project by running its install command in that directory:");
+  for (const c of cmds)
+    out.push(`  ${c}`);
+  out.push("", "Use --json for the full list.");
+  process.stdout.write(out.join(`
+`) + `
+`);
+  return 0;
+}
+
+// src/args.ts
+var VALUE_FLAGS = new Set(["--days", "--exclude", "--min-size", "--limit", "--log", "--depth", "--min-file", "--lsof"]);
+function parseArgs(argv) {
+  const flags = new Set;
+  const values = new Map;
+  const errors = [];
+  let command;
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      if (command === undefined)
+        command = a;
+      else
+        errors.push(`unexpected argument: ${a}`);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    const key = eq >= 0 ? a.slice(0, eq) : a;
+    if (VALUE_FLAGS.has(key)) {
+      const v = eq >= 0 ? a.slice(eq + 1) : argv[++i];
+      if (v === undefined) {
+        errors.push(`${key} requires a value`);
+        continue;
+      }
+      const list = values.get(key) ?? [];
+      list.push(v);
+      values.set(key, list);
+    } else {
+      flags.add(key);
+    }
+  }
+  return { command, flags, values, errors };
+}
+function firstValue(p, key) {
+  return p.values.get(key)?.[0];
+}
+
+// src/index.ts
+var USAGE = `d4c — dependency storage tooling for Git worktrees
+
+Usage:
+  d4c gc [options]
+  d4c dedupe [options]
+  d4c history [--limit N] [--json]
+
+  gc        Report node_modules trees idle long enough to delete safely,
+            and delete them with --yes. Dry-run by default.
+  dedupe    Make identical files across trees share storage. Deletes
+            nothing. Dry-run by default.
+  history   Show what previous runs deleted, and how to restore it.
+
+Options:
+  --days N          Idle threshold in days (default ${DEFAULT_DAYS})
+  --exclude PATTERN Protect matching paths. Repeatable. Supports * and **.
+  --min-size SIZE   Ignore trees smaller than this (e.g. 10M, 1G)
+  --depth N         How deep to search below the current directory (default 8)
+  --yes             Actually delete. Without it nothing is removed.
+  --json            Machine-readable output on stdout only.
+  --limit N         history: how many runs to show (default 5)
+  --min-file SIZE   dedupe: ignore files smaller than this (default 64K)
+  --skip-open-check dedupe: proceed without checking for open files
+  --lsof PATH       dedupe: path to lsof
+`;
+async function main(argv) {
+  const p = parseArgs(argv);
+  if (p.command === undefined || p.flags.has("--help") || p.command === "help") {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (p.errors.length > 0) {
+    for (const e of p.errors)
+      process.stderr.write(`${e}
+`);
+    return 70;
+  }
+  if (p.command === "gc") {
+    const daysRaw = firstValue(p, "--days");
+    const days = daysRaw === undefined ? DEFAULT_DAYS : Number(daysRaw);
+    if (!Number.isFinite(days) || days < 1) {
+      process.stderr.write(`--days must be at least 1
+`);
+      return 70;
+    }
+    const depthRaw = firstValue(p, "--depth");
+    if (depthRaw !== undefined && (!Number.isFinite(Number(depthRaw)) || Number(depthRaw) < 1)) {
+      process.stderr.write(`--depth must be a positive number
+`);
+      return 70;
+    }
+    const sizeRaw = firstValue(p, "--min-size");
+    const minSizeBytes = sizeRaw === undefined ? 0 : parseSize(sizeRaw) ?? -1;
+    if (minSizeBytes < 0) {
+      process.stderr.write(`--min-size: cannot parse ${JSON.stringify(sizeRaw)}
+`);
+      return 70;
+    }
+    return gc({
+      json: p.flags.has("--json"),
+      yes: p.flags.has("--yes"),
+      days,
+      cwd: process.cwd(),
+      exclude: p.values.get("--exclude") ?? [],
+      minSizeBytes,
+      logPath: firstValue(p, "--log"),
+      depth: depthRaw === undefined ? undefined : Number(depthRaw)
+    });
+  }
+  if (p.command === "dedupe") {
+    const daysRaw = firstValue(p, "--days");
+    const days = daysRaw === undefined ? DEDUPE_DEFAULT_DAYS : Number(daysRaw);
+    if (!Number.isFinite(days) || days < 1) {
+      process.stderr.write(`--days must be at least 1
+`);
+      return 70;
+    }
+    const mfRaw = firstValue(p, "--min-file");
+    const minFileBytes = mfRaw === undefined ? undefined : parseSize(mfRaw) ?? -1;
+    if (minFileBytes !== undefined && minFileBytes < 0) {
+      process.stderr.write(`--min-file: cannot parse ${JSON.stringify(mfRaw)}
+`);
+      return 70;
+    }
+    const depthRaw2 = firstValue(p, "--depth");
+    return dedupe({
+      json: p.flags.has("--json"),
+      yes: p.flags.has("--yes"),
+      days,
+      cwd: process.cwd(),
+      exclude: p.values.get("--exclude") ?? [],
+      minFileBytes,
+      skipOpenCheck: p.flags.has("--skip-open-check"),
+      lsofPath: firstValue(p, "--lsof"),
+      logPath: firstValue(p, "--log"),
+      depth: depthRaw2 === undefined ? undefined : Number(depthRaw2)
+    });
+  }
+  if (p.command === "history") {
+    const limitRaw = firstValue(p, "--limit");
+    const limit = limitRaw === undefined ? 5 : Number(limitRaw);
+    if (!Number.isFinite(limit) || limit < 1) {
+      process.stderr.write(`--limit must be a positive number
+`);
+      return 70;
+    }
+    return history({ json: p.flags.has("--json"), limit, logPath: firstValue(p, "--log") });
+  }
+  process.stderr.write(`unknown command: ${p.command}
+
+${USAGE}`);
+  return 70;
+}
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  process.stderr.write(`internal error: ${err?.stack ?? err}
+`);
+  process.exitCode = 70;
+});