@iyowei/sweep-node-modules 0.1.0

package/dist/cli.js

@@ -0,0 +1,1247 @@
+// src/cli.ts
+import { lstat as lstat2, mkdir, realpath as realpath3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename, dirname } from "node:path";
+
+// src/config.ts
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+function platformDefaultPath(platform, env, home) {
+  if (platform === "win32") {
+    const roaming = env.APPDATA || win32.join(env.USERPROFILE || home, "AppData", "Roaming");
+    return win32.join(roaming, "sweep-node-modules", "config.json");
+  }
+  return posix.join(home, ".config", "sweep-node-modules", "config.json");
+}
+function resolveConfigPath(options) {
+  if (options.flag) {
+    return { path: options.flag, source: "flag" };
+  }
+  const env = options.env ?? process.env;
+  if (env.SWEEP_NM_CONFIG) {
+    return { path: env.SWEEP_NM_CONFIG, source: "env" };
+  }
+  const platform = options.platform ?? process.platform;
+  const home = options.homedir ?? homedir();
+  return {
+    path: platformDefaultPath(platform, env, home),
+    source: "platform-default"
+  };
+}
+function describeActual(value) {
+  if (value === undefined)
+    return "缺失";
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+function fieldError(container, field, optional) {
+  const value = container[field];
+  if (value === undefined) {
+    return optional ? null : `${field} 应为字符串数组 (实际: 缺失)`;
+  }
+  if (!Array.isArray(value)) {
+    return `${field} 应为字符串数组 (实际: ${describeActual(value)})`;
+  }
+  const badIndex = value.findIndex((item) => typeof item !== "string");
+  if (badIndex !== -1) {
+    return `${field} 第 ${badIndex + 1} 项应为字符串 (实际: ${describeActual(value[badIndex])})`;
+  }
+  return null;
+}
+function shapeError(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return `顶层应为对象 (实际: ${describeActual(value)})`;
+  }
+  const candidate = value;
+  const rootsError = fieldError(candidate, "roots", false);
+  if (rootsError !== null)
+    return rootsError;
+  return fieldError(candidate, "exclude", true);
+}
+async function loadConfig(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { state: "absent" };
+    throw new Error(`配置读取失败 (${path}): ${error.message}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`配置损坏 (${path}): JSON 解析失败: ${error.message}`);
+  }
+  const error = shapeError(data);
+  if (error !== null) {
+    throw new Error(`配置损坏 (${path}): ${error}`);
+  }
+  const raw = data;
+  return {
+    state: "ok",
+    config: { roots: raw.roots, exclude: raw.exclude ?? [] }
+  };
+}
+async function loadResolvedConfig(resolved) {
+  const result = await loadConfig(resolved.path);
+  if (result.state === "absent" && resolved.source !== "platform-default") {
+    throw new Error(`配置不存在 (${resolved.path}), 请检查路径`);
+  }
+  return result;
+}
+function mergeExcludes(configExclude, cliExclude) {
+  return [...new Set([...configExclude, ...cliExclude])];
+}
+
+// src/delete.ts
+import { lstat, rm } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+var ERROR_HINTS = {
+  EACCES: "权限不足, 拒绝删除",
+  EPERM: "操作不被允许",
+  EBUSY: "目标被占用",
+  ENOTEMPTY: "目录非空",
+  EROFS: "目标位于只读文件系统"
+};
+var PARTIAL_DELETION_HINT = "注意: 目录内容可能已被部分或全部删除, 请复查";
+function describeCode(error) {
+  const fsError = error;
+  const code = fsError?.code;
+  if (typeof code !== "string" || code === "") {
+    return `未知错误: ${fsError?.message ?? String(error)}`;
+  }
+  return `${code}: ${ERROR_HINTS[code] ?? "删除未成功"}`;
+}
+function describeRemovalError(target, error) {
+  return `${describeCode(error)} (目标: ${target}; ${PARTIAL_DELETION_HINT})`;
+}
+function describeReviewError(target, path, error) {
+  return `安全复核未完成 (${describeCode(error)}) (目标: ${target}; 组件: ${path}; 未执行删除)`;
+}
+function describeVanishedReview(target, path) {
+  return `安全复核未完成 (ENOENT: 路径组件消失) (目标: ${target}; 组件: ${path}; 请复查目标是否仍存在; 未执行删除; 若目标确已不存在, 可忽略此条)`;
+}
+function isUnder(root, target) {
+  const rel = relative(root, target);
+  if (rel === "" || isAbsolute(rel))
+    return false;
+  return rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function componentChain(root, target) {
+  const chain = [root];
+  let cursor = root;
+  for (const part of relative(root, target).split(sep).slice(0, -1)) {
+    cursor = join(cursor, part);
+    chain.push(cursor);
+  }
+  return chain;
+}
+async function reviewComponents(chain) {
+  for (const path of chain) {
+    try {
+      const stats = await lstat(path);
+      if (!stats.isDirectory())
+        return { kind: "unsafe", path };
+    } catch (error) {
+      const code = error?.code;
+      if (code === "ENOENT")
+        return { kind: "vanished", path };
+      return { kind: "unverified", path, error };
+    }
+  }
+  return null;
+}
+async function removeTargets(targets, options) {
+  const result = { removed: [], missing: [], failed: [] };
+  const roots = options?.roots ?? [];
+  for (const target of targets) {
+    const root = roots.find((candidate) => isUnder(candidate, target));
+    if (root === undefined) {
+      result.aborted = {
+        target,
+        reason: `安全复核失败 (目标不在任何 roots 之下): ${target}`
+      };
+      break;
+    }
+    const finding = await reviewComponents(componentChain(root, target));
+    if (finding !== null) {
+      if (finding.kind === "vanished") {
+        result.failed.push({
+          target,
+          error: describeVanishedReview(target, finding.path)
+        });
+        continue;
+      }
+      if (finding.kind === "unsafe") {
+        result.aborted = {
+          target,
+          reason: `安全复核失败 (路径组件被替换): ${finding.path}`
+        };
+        break;
+      }
+      result.failed.push({
+        target,
+        error: describeReviewError(target, finding.path, finding.error)
+      });
+      continue;
+    }
+    try {
+      await rm(target, { recursive: true, force: false });
+      result.removed.push(target);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        result.missing.push(target);
+        continue;
+      }
+      result.failed.push({
+        target,
+        error: describeRemovalError(target, error)
+      });
+    }
+  }
+  return result;
+}
+
+// src/guard.ts
+import { realpath } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { posix as posix2, win32 as win322 } from "node:path";
+var POSIX_STYLE = {
+  name: "posix",
+  ops: posix2,
+  caseInsensitive: false
+};
+var WIN32_STYLE = {
+  name: "win32",
+  ops: win322,
+  caseInsensitive: true
+};
+function nativeStyle() {
+  return process.platform === "win32" ? WIN32_STYLE : POSIX_STYLE;
+}
+function fold(p, style) {
+  return style.caseInsensitive ? p.toLowerCase() : p;
+}
+function dedupeKey(realPath, style) {
+  return fold(realPath, style);
+}
+function hasNodeModulesLeaf(target, style) {
+  return fold(style.ops.basename(target), style) === "node_modules";
+}
+function insideAnyRoot(realPath, roots, style) {
+  return roots.some((root) => {
+    const rel = style.ops.relative(fold(root, style), fold(realPath, style));
+    if (rel === "" || style.ops.isAbsolute(rel))
+      return false;
+    return rel !== ".." && !rel.startsWith(`..${style.ops.sep}`);
+  });
+}
+function isFilesystemRootBody(realPath, style) {
+  return fold(style.ops.parse(realPath).root, style) === fold(realPath, style);
+}
+function isHomeBody(realPath, home, style) {
+  return home !== null && dedupeKey(realPath, style) === dedupeKey(home, style);
+}
+async function tryRealpath(p) {
+  try {
+    return await realpath(p);
+  } catch {
+    return null;
+  }
+}
+async function validateTargets(targets, options) {
+  const style = options.style ?? nativeStyle();
+  const homeOption = options.home === undefined ? homedir2() : options.home;
+  const roots = [];
+  for (const root of options.roots) {
+    const real = await tryRealpath(root);
+    if (real !== null)
+      roots.push(real);
+  }
+  const home = homeOption === null ? null : await tryRealpath(homeOption) ?? homeOption;
+  const accepted = [];
+  const rejected = [];
+  const seen = new Set;
+  for (const target of targets) {
+    if (!hasNodeModulesLeaf(target, style)) {
+      rejected.push({ target, reason: "路径末段不是 node_modules" });
+      continue;
+    }
+    const real = await tryRealpath(target);
+    if (real === null) {
+      rejected.push({ target, reason: "realpath 失败 (目标不存在或不可读)" });
+      continue;
+    }
+    if (isFilesystemRootBody(real, style)) {
+      rejected.push({ target, reason: "目标是文件系统根本体" });
+      continue;
+    }
+    if (isHomeBody(real, home, style)) {
+      rejected.push({ target, reason: "目标是 home 本体" });
+      continue;
+    }
+    if (!hasNodeModulesLeaf(real, style)) {
+      rejected.push({ target, reason: "realpath 后的末段不是 node_modules" });
+      continue;
+    }
+    if (!insideAnyRoot(real, roots, style)) {
+      rejected.push({ target, reason: "realpath 后不在任何 root 之下" });
+      continue;
+    }
+    const key = dedupeKey(real, style);
+    if (seen.has(key)) {
+      rejected.push({ target, reason: "重复目标 (realpath 去重)" });
+      continue;
+    }
+    seen.add(key);
+    accepted.push(real);
+  }
+  return { accepted, rejected };
+}
+
+// src/init.ts
+import { homedir as homedir3 } from "node:os";
+import { join as join2 } from "node:path";
+import { createInterface } from "node:readline/promises";
+var WHITESPACE = /\s/;
+function expandHome(token) {
+  if (token === "~")
+    return homedir3();
+  if (token.startsWith("~/") || token.startsWith("~\\"))
+    return join2(homedir3(), token.slice(2));
+  return token;
+}
+function splitAnswer(answer) {
+  const items = [];
+  let current = "";
+  let openQuote = null;
+  for (let index = 0;index < answer.length; index += 1) {
+    const char = answer[index];
+    if (openQuote !== null) {
+      if (char === openQuote) {
+        openQuote = null;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      if (answer.indexOf(char, index + 1) !== -1) {
+        openQuote = char;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "," || char === "，" || WHITESPACE.test(char)) {
+      if (current.length > 0)
+        items.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0)
+    items.push(current);
+  return items;
+}
+function parseList(answer, fallback) {
+  if (answer === null)
+    return [...fallback];
+  const items = splitAnswer(answer).map(expandHome);
+  return items.length > 0 ? items : [...fallback];
+}
+async function runInit(deps) {
+  const { configPath, fileExists, writeFile, io } = deps;
+  function cancelled() {
+    io.print("已取消, 未写入配置");
+    return { state: "cancelled" };
+  }
+  if (await fileExists(configPath)) {
+    const overwrite = await io.confirm(`配置已存在 (${configPath}), 是否覆盖?`, false);
+    if (!overwrite)
+      return { state: "declined-overwrite" };
+  }
+  io.print("首次使用, 先确定扫描范围");
+  const cwd = process.cwd();
+  let roots = [];
+  for (;; ) {
+    const rootsAnswer = await io.ask("扫描根 (逗号或空白分隔多个)", `默认: ${cwd}`);
+    if (rootsAnswer === null)
+      return cancelled();
+    roots = parseList(rootsAnswer, [cwd]);
+    const missing = [];
+    for (const root of roots) {
+      if (!await fileExists(root))
+        missing.push(root);
+    }
+    if (missing.length === 0)
+      break;
+    for (const path of missing)
+      io.print(`根不存在: ${path}`);
+  }
+  const excludeAnswer = await io.ask("排除名单 (目录名, 可留空)", "回车跳过");
+  if (excludeAnswer === null)
+    return cancelled();
+  const exclude = parseList(excludeAnswer, []);
+  io.print(`将写入 roots: ${JSON.stringify(roots)} · exclude: ${JSON.stringify(exclude)}`);
+  if (!await io.confirm("确认写入?", true))
+    return cancelled();
+  const config = { roots, exclude };
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  io.print(`配置已写入: ${configPath}`);
+  return { state: "written", config };
+}
+function setStdinRef(shouldRef) {
+  const fn = shouldRef ? process.stdin.ref : process.stdin.unref;
+  if (typeof fn === "function")
+    fn.call(process.stdin);
+}
+function createReadlineIO() {
+  const buffered = [];
+  let rl = null;
+  let ended = false;
+  let pending = null;
+  function ensure() {
+    if (rl !== null)
+      return rl;
+    const created = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    created.on("line", (line) => {
+      if (pending === null) {
+        buffered.push(line);
+        return;
+      }
+      const resolve = pending;
+      pending = null;
+      setStdinRef(false);
+      resolve(line);
+    });
+    created.on("close", () => {
+      ended = true;
+      if (pending === null)
+        return;
+      const resolve = pending;
+      pending = null;
+      setStdinRef(false);
+      resolve(null);
+    });
+    created.on("SIGINT", () => created.close());
+    rl = created;
+    return created;
+  }
+  function readLine(prompt) {
+    if (ended)
+      return Promise.resolve(null);
+    const created = ensure();
+    created.setPrompt(prompt);
+    created.prompt();
+    const ready = buffered.shift();
+    if (ready !== undefined)
+      return Promise.resolve(ready);
+    setStdinRef(true);
+    return new Promise((resolve) => {
+      pending = resolve;
+    });
+  }
+  return {
+    ask(question, hint) {
+      const prompt = hint === undefined ? `${question} ` : `${question} [${hint}] `;
+      return readLine(prompt);
+    },
+    async confirm(question, defaultYes) {
+      const mark = defaultYes ? "(Y/n)" : "(y/N)";
+      const answer = await readLine(`${question} ${mark} `);
+      if (answer === null)
+        return false;
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "")
+        return defaultYes;
+      return normalized === "y" || normalized === "yes";
+    },
+    print(line) {
+      process.stdout.write(`${line}
+`);
+    }
+  };
+}
+
+// src/render.ts
+var BANNER = "SWEEP-NM";
+var BAR_BLOCK = "▍";
+var TOTAL_BLOCK = "█";
+var NEUTRAL_BLOCK = "░";
+var PLATFORM_STYLE = nativeStyle();
+var NEUTRAL_TIER = { block: NEUTRAL_BLOCK, sgr: "2" };
+var ROOT_LIST_LIMIT = 3;
+var TIER_BIG = 1024 ** 3;
+var TIER_MID = 100 * 1024 ** 2;
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${Math.round(bytes)} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let index = -1;
+  do {
+    value /= 1024;
+    index += 1;
+  } while (value >= 1024 && index < units.length - 1);
+  return `${Math.round(value * 10) / 10} ${units[index]}`;
+}
+function render(options) {
+  const { mode, roots, entries, color, home, releasedBytes, pathStyle } = options;
+  const style = pathStyle ?? PLATFORM_STYLE;
+  const scope = roots.length > 0 && roots.length <= ROOT_LIST_LIMIT ? `${roots.length} 个根: ${roots.map((root) => oneLine(shortenPath(root, style, home))).join(" · ")}` : `${roots.length} 个根`;
+  const head = paint(`${BAR_BLOCK} ${BANNER}  ${mode === "execute" ? "执行" : "预览"} · ${scope}`, "1;7", color);
+  if (entries.length === 0) {
+    return [
+      head,
+      `  ${paint(`${NEUTRAL_BLOCK} 未发现 node_modules`, "2", color)}`
+    ].join(`
+`);
+  }
+  const rows = [...entries].sort((a, b) => (b.bytes ?? -1) - (a.bytes ?? -1));
+  const volumeWidth = Math.max(...rows.map((row) => displayWidth(volumeOf(row))));
+  const nameWidth = Math.max(...rows.map((row) => displayWidth(oneLine(row.project))));
+  const body = rows.map((row) => {
+    const fail = mode === "execute" && row.ok === false;
+    const tier = row.bytes === undefined ? NEUTRAL_TIER : tierOf(row.bytes);
+    const mark = mode === "execute" ? paint(fail ? "✗" : "✓", fail ? "31" : "32", color) : paint(tier.block, tier.sgr, color);
+    const volume = padStart(volumeOf(row), volumeWidth);
+    const name = oneLine(row.project);
+    const rawPath = displayPath(row.target, style, home);
+    const path = oneLine(rawPath);
+    const rewritten = name !== row.project || path !== rawPath;
+    const tail = tailsOf(row, fail, rewritten);
+    const shown = `${paint(padEnd(name, nameWidth), "1", color)}    ${paint(path, "2", color)}`;
+    return `  ${mark} ${volume}  ${shown}${tail ? `  ${paint(tail, "2", color)}` : ""}`;
+  });
+  const hint = [
+    paint("加", "2", color),
+    paint("--yes", "1", color),
+    paint("执行删除", "2", color)
+  ].join(" ");
+  const foot = mode === "execute" ? footExecute(rows, color, releasedBytes) : `  ${paint(TOTAL_BLOCK, "7", color)} ${paint(`合计 ${rows.length} 处 · ${formatBytes(sum(rows))}`, "1", color)}   ${hint}`;
+  return [head, ...body, foot].join(`
+`);
+}
+function footExecute(rows, color, releasedBytes) {
+  const failed = rows.filter((row) => row.ok === false).length;
+  const released = releasedBytes === undefined ? "" : ` · 释放 ${formatBytes(releasedBytes)}`;
+  return `  ${paint(TOTAL_BLOCK, "7", color)} ${paint(`汇总 成功 ${rows.length - failed} 处${released} · 失败 ${failed} 处`, "1", color)}`;
+}
+var volumeOf = (row) => row.bytes === undefined ? "?" : formatBytes(row.bytes);
+var SANITIZED_NOTE = "名字已净化显示";
+function tailsOf(row, fail, rewritten) {
+  const parts = [];
+  if (rewritten)
+    parts.push(SANITIZED_NOTE);
+  if (row.note)
+    parts.push(oneLine(row.note));
+  if (fail && row.error)
+    parts.push(oneLine(row.error));
+  return parts.join("  ");
+}
+function tierOf(bytes) {
+  if (bytes >= TIER_BIG)
+    return { block: "█", sgr: "31" };
+  if (bytes >= TIER_MID)
+    return { block: "▓", sgr: "33" };
+  return { block: "▒", sgr: "36" };
+}
+var paint = (text, sgr, color) => color ? `\x1B[${sgr}m${text}\x1B[0m` : text;
+var sum = (rows) => rows.reduce((total, row) => total + (row.bytes ?? 0), 0);
+var fold2 = (text, style) => style.caseInsensitive ? text.toLowerCase() : text;
+function shortenPath(path, style, home) {
+  if (!home)
+    return path;
+  if (fold2(path, style) === fold2(home, style))
+    return "~";
+  const prefix = `${home}${style.ops.sep}`;
+  return fold2(path, style).startsWith(fold2(prefix, style)) ? `~${path.slice(home.length)}` : path;
+}
+function displayPath(target, style, home) {
+  const suffix = `${style.ops.sep}node_modules`;
+  const dir = fold2(target, style).endsWith(fold2(suffix, style)) ? target.slice(0, -suffix.length) : target;
+  return shortenPath(dir, style, home);
+}
+var oneLine = (text) => text.replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u200b-\u200f\u202a-\u202e\u2066-\u2069\ufeff]/g, "").replace(/\s+/g, " ").trim();
+var padEnd = (text, width) => text + " ".repeat(Math.max(0, width - displayWidth(text)));
+var padStart = (text, width) => " ".repeat(Math.max(0, width - displayWidth(text))) + text;
+function displayWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    width += isFullWidth(code) ? 2 : 1;
+  }
+  return width;
+}
+function isFullWidth(code) {
+  return code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510;
+}
+
+// src/runtime.ts
+import { readFile as readFile2, writeFile } from "node:fs/promises";
+var isBun = typeof Bun !== "undefined";
+async function writeTextFile(path, text) {
+  if (isBun) {
+    await Bun.write(path, text);
+    return;
+  }
+  await writeFile(path, text, "utf8");
+}
+
+// src/scan-parallel.ts
+import { readdir, realpath as realpath2, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var NODE_MODULES = "node_modules";
+var GIT_DIR = ".git";
+var CONCURRENCY = 32;
+function compareTarget(a, b) {
+  if (a.target < b.target)
+    return -1;
+  if (a.target > b.target)
+    return 1;
+  return 0;
+}
+function describeRootFailure(error) {
+  const { code } = error;
+  switch (code) {
+    case "ENOENT":
+      return "根不存在";
+    case "EACCES":
+    case "EPERM":
+      return "根不可读 (权限不足)";
+    case "ENOTDIR":
+      return "根不是目录";
+    default:
+      return `根不可用 (${code ?? "UNKNOWN"})`;
+  }
+}
+async function walkRoot(root, style, exclude, excludeCounts, hits, warnings) {
+  const stack = [root];
+  let outstanding = 1;
+  let active = 0;
+  const failures = [];
+  let resolveDrained = null;
+  const drained = new Promise((resolve) => {
+    resolveDrained = resolve;
+  });
+  function pump() {
+    while (active < CONCURRENCY && stack.length > 0) {
+      const dir = stack.pop();
+      active += 1;
+      visit(dir);
+    }
+    if (outstanding === 0 && resolveDrained !== null) {
+      const resolve = resolveDrained;
+      resolveDrained = null;
+      resolve();
+    }
+  }
+  async function visit(dir) {
+    try {
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch {
+        warnings.push(`目录不可读, 已跳过: ${dir}`);
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const name = entry.name;
+        if (name === NODE_MODULES) {
+          const target = join3(dir, name);
+          const key = dedupeKey(await realpath2(target).catch(() => target), style);
+          if (!hits.has(key))
+            hits.set(key, { project: dir, target });
+          continue;
+        }
+        if (name === GIT_DIR)
+          continue;
+        if (exclude.has(name)) {
+          excludeCounts.set(name, (excludeCounts.get(name) ?? 0) + 1);
+          continue;
+        }
+        stack.push(join3(dir, name));
+        outstanding += 1;
+      }
+    } catch (error) {
+      if (failures.length === 0)
+        failures.push(error);
+    } finally {
+      active -= 1;
+      outstanding -= 1;
+      pump();
+    }
+  }
+  pump();
+  await drained;
+  if (failures.length > 0)
+    throw failures[0];
+}
+function createParallelScanner() {
+  return {
+    name: "parallel",
+    async scan(options) {
+      const warnings = [];
+      const exclude = new Set(options.exclude);
+      const excludeCounts = new Map;
+      for (const name of options.exclude) {
+        if (!excludeCounts.has(name))
+          excludeCounts.set(name, 0);
+      }
+      const hitsByRealTarget = new Map;
+      const style = nativeStyle();
+      const seenRoots = new Set;
+      const roots = [];
+      for (const root of options.roots) {
+        let key;
+        try {
+          const resolved = await realpath2(root);
+          if (!(await stat(resolved)).isDirectory()) {
+            warnings.push(`根不是目录, 已跳过: ${root}`);
+            continue;
+          }
+          key = dedupeKey(resolved, style);
+        } catch (error) {
+          warnings.push(`${describeRootFailure(error)}, 已跳过: ${root}`);
+          continue;
+        }
+        if (seenRoots.has(key))
+          continue;
+        seenRoots.add(key);
+        roots.push(root);
+      }
+      for (const root of roots) {
+        await walkRoot(root, style, exclude, excludeCounts, hitsByRealTarget, warnings);
+      }
+      const hits = [...hitsByRealTarget.values()].sort(compareTarget);
+      const excludeMatches = options.exclude.map((name) => ({
+        name,
+        hits: excludeCounts.get(name) ?? 0
+      }));
+      return { hits, warnings, excludeMatches };
+    }
+  };
+}
+// src/size-du.ts
+import { spawn } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+var DU_PROBES = ["/usr/bin/du", "/bin/du"];
+var hasControlChar = (target) => target.includes(`
+`) || target.includes("\r");
+function findDu() {
+  for (const probe of DU_PROBES) {
+    try {
+      accessSync(probe, constants.X_OK);
+      return probe;
+    } catch {}
+  }
+  return null;
+}
+function runDu(bin, targets) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, ["-sk", "--", ...targets], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      resolve({ stdout, stderr: `${stderr}${String(error)}` });
+    });
+    child.on("close", () => resolve({ stdout, stderr }));
+  });
+}
+function parseDuSizes(stdout) {
+  const sizes = new Map;
+  let duplicated = false;
+  for (const line of stdout.split(`
+`)) {
+    const match = /^(\d+)\t(.+)$/.exec(line);
+    if (match === null)
+      continue;
+    const sizeKiB = match[1];
+    const path = match[2];
+    if (sizeKiB === undefined || path === undefined)
+      continue;
+    if (sizes.has(path))
+      duplicated = true;
+    sizes.set(path, Number(sizeKiB) * 1024);
+  }
+  return { sizes, duplicated };
+}
+function describeDuFailure(detail) {
+  if (/no such file or directory/i.test(detail))
+    return { reason: "不存在", missing: true };
+  if (/permission denied/i.test(detail))
+    return { reason: "权限不足, 无法读取", missing: false };
+  if (/not a directory/i.test(detail))
+    return { reason: "不是目录", missing: false };
+  if (/too many levels of symbolic links/i.test(detail)) {
+    return { reason: "符号链接层级过深", missing: false };
+  }
+  return { reason: `读取失败 (${detail})`, missing: false };
+}
+function parseDuErrorLine(line) {
+  const match = /^du:\s+(.+):\s+(.+)$/.exec(line);
+  if (match === null)
+    return null;
+  const path = match[1];
+  const detail = match[2];
+  if (path === undefined || detail === undefined)
+    return null;
+  return { path, detail };
+}
+function createDuSizer() {
+  const bin = findDu();
+  return {
+    name: "du",
+    async measure(targets) {
+      if (bin === null) {
+        return {
+          entries: [],
+          warnings: [
+            "du 候选不可用: /usr/bin/du 与 /bin/du 均不存在, 本候选跳过体积统计"
+          ],
+          unmeasured: []
+        };
+      }
+      if (targets.length === 0) {
+        return { entries: [], warnings: [], unmeasured: [] };
+      }
+      const sorted = [...targets].sort();
+      const warnings = [];
+      const entries = [];
+      const unmeasured = [];
+      const safeTargets = sorted.filter((target) => !hasControlChar(target));
+      const safeSet = new Set(safeTargets);
+      const sizes = new Map;
+      const failures = new Map;
+      let intact = true;
+      if (safeTargets.length > 0) {
+        const { stdout, stderr } = await runDu(bin, safeTargets);
+        const parsed = parseDuSizes(stdout);
+        intact = !parsed.duplicated && parsed.sizes.size <= safeTargets.length && [...parsed.sizes.keys()].every((path) => safeSet.has(path));
+        for (const [path, bytes] of parsed.sizes)
+          sizes.set(path, bytes);
+        for (const line of stderr.split(`
+`)) {
+          if (line.trim() === "")
+            continue;
+          const errorLine = parseDuErrorLine(line);
+          if (errorLine === null) {
+            warnings.push(`体积统计失败 (未归因): ${line.trim()}`);
+            continue;
+          }
+          const failure = describeDuFailure(errorLine.detail);
+          if (!safeSet.has(errorLine.path)) {
+            warnings.push(`体积统计失败 (${failure.reason}): ${errorLine.path}`);
+            continue;
+          }
+          failures.set(errorLine.path, failure);
+        }
+      }
+      for (const target of sorted) {
+        if (hasControlChar(target)) {
+          unmeasured.push({ target, reason: "路径含控制字符" });
+          continue;
+        }
+        if (!intact) {
+          unmeasured.push({ target, reason: "输出不可解析" });
+          continue;
+        }
+        const bytes = sizes.get(target);
+        if (bytes !== undefined) {
+          entries.push({ target, bytes });
+          continue;
+        }
+        const failure = failures.get(target);
+        if (failure === undefined) {
+          unmeasured.push({ target, reason: "输出不可解析" });
+          continue;
+        }
+        if (failure.missing) {
+          warnings.push(`体积统计失败 (不存在): ${target}`);
+          continue;
+        }
+        unmeasured.push({ target, reason: failure.reason });
+      }
+      return { entries, warnings, unmeasured };
+    }
+  };
+}
+
+// src/size-js.ts
+import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function describeFailure(code) {
+  switch (code) {
+    case "ENOENT":
+      return "不存在";
+    case "EACCES":
+    case "EPERM":
+      return "权限不足, 无法读取";
+    case "ENOTDIR":
+      return "不是目录";
+    case "ELOOP":
+      return "符号链接层级过深";
+    default:
+      return code === undefined ? "读取失败" : `读取失败 (${code})`;
+  }
+}
+function errorCode(error) {
+  return error?.code;
+}
+async function sumEntries(dirents, dir, warnings) {
+  let total = 0;
+  for (const dirent of dirents) {
+    if (dirent.isSymbolicLink())
+      continue;
+    const path = join4(dir, dirent.name);
+    if (dirent.isDirectory()) {
+      try {
+        total += await sumEntries(await readdir2(path, { withFileTypes: true }), path, warnings);
+      } catch (error) {
+        warnings.push(`体积统计失败 (${describeFailure(errorCode(error))}): ${path}`);
+      }
+    } else if (dirent.isFile()) {
+      try {
+        total += (await stat2(path)).size;
+      } catch (error) {
+        warnings.push(`体积统计失败 (${describeFailure(errorCode(error))}): ${path}`);
+      }
+    }
+  }
+  return total;
+}
+function createJsSizer() {
+  return {
+    name: "js",
+    async measure(targets) {
+      const warnings = [];
+      const entries = [];
+      const unmeasured = [];
+      for (const target of [...targets].sort()) {
+        let dirents;
+        try {
+          dirents = await readdir2(target, { withFileTypes: true });
+        } catch (error) {
+          const code = errorCode(error);
+          if (code === "ENOENT") {
+            warnings.push(`体积统计失败 (不存在): ${target}`);
+          } else {
+            unmeasured.push({ target, reason: describeFailure(code) });
+          }
+          continue;
+        }
+        entries.push({
+          target,
+          bytes: await sumEntries(dirents, target, warnings)
+        });
+      }
+      return { entries, warnings, unmeasured };
+    }
+  };
+}
+
+// src/size.ts
+function createSizer() {
+  return findDu() !== null ? createDuSizer() : createJsSizer();
+}
+
+// src/cli.ts
+var COMMAND_COLUMN = 25;
+function parseArgs(argv) {
+  const options = {
+    command: "sweep",
+    yes: false,
+    exclude: [],
+    help: false
+  };
+  const positionals = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === undefined)
+      continue;
+    if (arg === "--yes") {
+      options.yes = true;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--exclude" || arg === "--config") {
+      const value = argv[index + 1];
+      if (value === undefined || value.startsWith("-")) {
+        return { ok: false, message: `参数 ${arg} 缺少取值` };
+      }
+      if (arg === "--exclude")
+        options.exclude.push(value);
+      else
+        options.config = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-"))
+      return { ok: false, message: `未知参数: ${arg}` };
+    positionals.push(arg);
+  }
+  const [only] = positionals;
+  if (positionals.length > 1 || only !== undefined && only !== "init") {
+    return { ok: false, message: `未知参数: ${positionals.join(" ")}` };
+  }
+  if (only === "init")
+    options.command = "init";
+  return { ok: true, options };
+}
+function colorEnabled() {
+  return process.stdout.isTTY === true && !process.env.NO_COLOR;
+}
+function interactive() {
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function print(line) {
+  process.stdout.write(`${line}
+`);
+}
+function warn(line, color) {
+  process.stderr.write(color ? `${paint("✗", "31", color)} ${line}
+` : `${line}
+`);
+}
+function notice(line) {
+  process.stderr.write(`${line}
+`);
+}
+function defaultConfigPath() {
+  return resolveConfigPath({ env: {} }).path;
+}
+function helpText(color) {
+  const row = (command, desc) => `  ${command.padEnd(COMMAND_COLUMN)}  ${desc}`;
+  return [
+    `${paint(`${BAR_BLOCK} SWEEP-NM`, "1;7", color)}  工作区 node_modules 清理`,
+    "",
+    row("sweep-nm", "预览: 清单 + 体积 + 合计, 零副作用"),
+    row("sweep-nm --yes", "执行删除"),
+    row("sweep-nm --exclude <name>", "临时追加排除 (可重复, 与配置合并)"),
+    row("sweep-nm --config <path>", "指定配置文件 (优先于 SWEEP_NM_CONFIG)"),
+    row("sweep-nm init", "初始化向导: 交互生成配置文件"),
+    row("sweep-nm --help", "帮助"),
+    "",
+    "说明:",
+    "  --exclude 按目录名精确匹配 (区分大小写), 从根到命中点的任意一级命中即跳过",
+    `  默认配置位置 (平台自适应): ${defaultConfigPath()}`,
+    "",
+    "退出码: 0 成功 (含预览与空结果); 1 删除失败 / 配置损坏 / 参数错误"
+  ].join(`
+`);
+}
+function runWizard(configPath) {
+  return runInit({
+    configPath,
+    async fileExists(path) {
+      try {
+        await lstat2(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async writeFile(path, text) {
+      await mkdir(dirname(path), { recursive: true });
+      await writeTextFile(path, text);
+    },
+    io: createReadlineIO()
+  });
+}
+async function resolveConfig(resolved) {
+  const loaded = await loadResolvedConfig(resolved);
+  if (loaded.state === "ok")
+    return { config: loaded.config, source: "file" };
+  if (!interactive())
+    return {
+      config: { roots: [process.cwd()], exclude: [] },
+      source: "fallback"
+    };
+  const result = await runWizard(resolved.path);
+  if (result.state === "written" && result.config !== undefined) {
+    return { config: result.config, source: "wizard" };
+  }
+  print("配置未写入, 本次未执行清理");
+  return null;
+}
+var ABORTED_HINT = "整批中止, 未执行删除";
+async function realRoots(roots) {
+  return Promise.all(roots.map(async (root) => await realpath3(root).catch(() => null) ?? root));
+}
+function withOutcomes(entries, batch, accepted, removal) {
+  const outcomes = new Map;
+  for (const target of removal.removed)
+    outcomes.set(target, { ok: true });
+  for (const target of removal.missing)
+    outcomes.set(target, { ok: true });
+  for (const item of removal.failed)
+    outcomes.set(item.target, { ok: false, error: item.error });
+  const byTarget = new Map;
+  for (const [index, target] of batch.entries()) {
+    const real = accepted[index];
+    const outcome = real === undefined ? undefined : outcomes.get(real);
+    if (outcome !== undefined)
+      byTarget.set(target, outcome);
+  }
+  const fallback = removal.aborted === undefined ? { ok: false } : { ok: false, error: ABORTED_HINT };
+  return entries.map((entry) => ({
+    ...entry,
+    ...byTarget.get(entry.target) ?? fallback
+  }));
+}
+function reportExcludeMatches(matches, color) {
+  if (matches === undefined)
+    return;
+  const tty = process.stderr.isTTY === true;
+  for (const item of matches) {
+    if (item.hits === 0)
+      warn(`排除名未匹配到任何目录: ${item.name} (按目录名精确匹配)`, color);
+    else if (tty)
+      notice(`排除生效: ${item.name} (${item.hits} 处)`);
+  }
+}
+function toEntries(hits, sizeResult) {
+  const bytesOf = new Map(sizeResult.entries.map((entry) => [
+    entry.target,
+    entry.bytes
+  ]));
+  const reasonOf = new Map(sizeResult.unmeasured.map((item) => [
+    item.target,
+    item.reason
+  ]));
+  const entries = [];
+  for (const hit of hits) {
+    const project = basename(hit.project);
+    const bytes = bytesOf.get(hit.target);
+    if (bytes !== undefined) {
+      entries.push({ project, target: hit.target, bytes });
+      continue;
+    }
+    const reason = reasonOf.get(hit.target);
+    if (reason !== undefined) {
+      entries.push({
+        project,
+        target: hit.target,
+        note: `体积统计失败: ${reason}`
+      });
+    }
+  }
+  return entries;
+}
+async function sweep(config, options, color) {
+  const roots = config.roots;
+  const exclude = mergeExcludes(config.exclude, options.exclude);
+  const scanResult = await createParallelScanner().scan({ roots, exclude });
+  for (const warning of scanResult.warnings)
+    warn(warning, color);
+  reportExcludeMatches(scanResult.excludeMatches, color);
+  const sizeResult = await createSizer().measure(scanResult.hits.map((hit) => hit.target));
+  for (const warning of sizeResult.warnings)
+    warn(warning, color);
+  const entries = toEntries(scanResult.hits, sizeResult);
+  const home = homedir4();
+  if (!options.yes) {
+    print(render({ mode: "preview", roots, entries, color, home }));
+    return 0;
+  }
+  const batch = entries.filter((entry) => entry.bytes !== undefined).map((entry) => entry.target);
+  const { accepted, rejected } = await validateTargets(batch, { roots });
+  if (rejected.length > 0) {
+    warn(`整批拒绝: ${rejected.length} 个目标未通过安全闸, 未执行任何删除`, color);
+    for (const item of rejected)
+      notice(`  ${item.target} (${item.reason})`);
+    return 1;
+  }
+  const removal = await removeTargets(accepted, {
+    roots: await realRoots(roots)
+  });
+  const report = withOutcomes(entries, batch, accepted, removal);
+  const releasedBytes = report.reduce((total, entry) => entry.ok === false ? total : total + (entry.bytes ?? 0), 0);
+  print(render({
+    mode: "execute",
+    roots,
+    entries: report,
+    color,
+    home,
+    releasedBytes
+  }));
+  if (removal.aborted !== undefined) {
+    warn(`整批中止: ${removal.aborted.reason}`, color);
+    notice(`  本轮未执行删除: ${batch.length} 处`);
+  }
+  return report.some((entry) => entry.ok === false) ? 1 : 0;
+}
+async function main() {
+  const color = colorEnabled();
+  const parsed = parseArgs(process.argv.slice(2));
+  if (!parsed.ok) {
+    warn(`参数错误: ${parsed.message} (用 --help 查看用法)`, color);
+    return 1;
+  }
+  const { options } = parsed;
+  if (options.help) {
+    print(helpText(color));
+    return 0;
+  }
+  try {
+    const resolvedPath = resolveConfigPath({ flag: options.config });
+    if (options.command === "init") {
+      if (!interactive()) {
+        warn("init 需要交互终端 (请在终端直接运行, 不要重定向或经管道)", color);
+        return 1;
+      }
+      const result = await runWizard(resolvedPath.path);
+      if (result.state === "written")
+        print("运行 sweep-nm 查看预览");
+      else
+        print("配置未变更");
+      return 0;
+    }
+    const resolved = await resolveConfig(resolvedPath);
+    if (resolved === null)
+      return 0;
+    if (resolved.source === "fallback") {
+      const roots = resolved.config.roots.join(", ");
+      if (options.yes) {
+        warn("拒绝执行: 当前无配置文件, --yes 不可用", color);
+        notice(`  将扫的根: ${roots}`);
+        notice("  先 sweep-nm init 生成配置, 或用 --config 指定配置文件");
+        return 1;
+      }
+      notice(`未找到配置文件, 本次以当前目录为根: ${roots} (想固定此设置, 运行 sweep-nm init)`);
+    }
+    const freshConfig = resolved.source === "wizard";
+    if (freshConfig && options.yes) {
+      notice("首次配置已生成; 本轮先预览, 复核后可再运行 --yes 执行");
+    }
+    return await sweep(resolved.config, freshConfig ? { ...options, yes: false } : options, color);
+  } catch (error) {
+    warn(error instanceof Error ? error.message : String(error), color);
+    return 1;
+  }
+}
+process.exitCode = await main();