prunify 0.1.5 → 0.1.7

package/dist/cli.cjs

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander = require("commander");
 var import_chalk7 = __toESM(require("chalk"), 1);
 var import_cli_table36 = __toESM(require("cli-table3"), 1);
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_node_readline = __toESM(require("readline"), 1);
 
@@ -238,16 +238,93 @@ function findEntryPoints(rootDir, packageJson) {
   ];
   return [...new Set(entries)];
 }
+var APP_SPECIAL_ENTRY_BASENAMES_LOWER = /* @__PURE__ */ new Set([
+  "page.tsx",
+  "page.ts",
+  "page.jsx",
+  "page.js",
+  "layout.tsx",
+  "layout.ts",
+  "layout.jsx",
+  "layout.js",
+  "template.tsx",
+  "template.ts",
+  "template.jsx",
+  "template.js",
+  "loading.tsx",
+  "loading.ts",
+  "loading.jsx",
+  "loading.js",
+  "error.tsx",
+  "error.ts",
+  "error.jsx",
+  "error.js",
+  "global-error.tsx",
+  "global-error.ts",
+  "global-error.jsx",
+  "global-error.js",
+  "not-found.tsx",
+  "not-found.ts",
+  "not-found.jsx",
+  "not-found.js",
+  "forbidden.tsx",
+  "forbidden.ts",
+  "forbidden.jsx",
+  "forbidden.js",
+  "unauthorized.tsx",
+  "unauthorized.ts",
+  "unauthorized.jsx",
+  "unauthorized.js",
+  "default.tsx",
+  "default.ts",
+  "default.jsx",
+  "default.js",
+  "route.ts",
+  "route.js",
+  "opengraph-image.tsx",
+  "opengraph-image.ts",
+  "opengraph-image.js",
+  "twitter-image.tsx",
+  "twitter-image.ts",
+  "twitter-image.js",
+  "icon.tsx",
+  "icon.ts",
+  "icon.jsx",
+  "icon.js",
+  "apple-icon.tsx",
+  "apple-icon.ts",
+  "apple-icon.js",
+  "sitemap.ts",
+  "sitemap.js",
+  "robots.ts",
+  "robots.js",
+  "manifest.ts",
+  "manifest.js"
+]);
+function isConventionRoutedSourceFile(filePath, rootDir) {
+  const rel = import_node_path3.default.relative(rootDir, import_node_path3.default.normalize(filePath)).replaceAll("\\", "/");
+  if (rel.startsWith("..")) return false;
+  if (rel === "pages" || rel.startsWith("pages/")) return true;
+  if (rel.startsWith("src/pages/")) return true;
+  if (rel.startsWith("src/routes/") || rel.startsWith("src/views/") || rel.startsWith("src/screens/")) {
+    return true;
+  }
+  if (rel.startsWith("app/") || rel.startsWith("src/app/")) {
+    const base = import_node_path3.default.basename(rel).toLowerCase();
+    if (APP_SPECIAL_ENTRY_BASENAMES_LOWER.has(base)) return true;
+  }
+  return false;
+}
 function detectCycles(graph) {
   const cycles = [];
   const seenKeys = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const inStack = /* @__PURE__ */ new Set();
-  const path10 = [];
+  const path11 = [];
   const acc = { seenKeys, cycles };
   for (const start of graph.keys()) {
     if (!visited.has(start)) {
-      dfsForCycles(start, graph, visited, inStack, path10, acc);
+      dfsForCycles(start, graph, visited, inStack, path11, acc);
     }
   }
   return cycles;
@@ -305,7 +382,7 @@ function resolveFallbackEntries(rootDir) {
 function mkFrame(node, graph) {
   return { node, neighbors: (graph.get(node) ?? /* @__PURE__ */ new Set()).values(), entered: false };
 }
-function dfsForCycles(start, graph, visited, inStack, path10, acc) {
+function dfsForCycles(start, graph, visited, inStack, path11, acc) {
   const stack = [mkFrame(start, graph)];
   while (stack.length > 0) {
     const frame = stack.at(-1);
@@ -317,30 +394,30 @@ function dfsForCycles(start, graph, visited, inStack, path10, acc) {
       }
       frame.entered = true;
       inStack.add(frame.node);
-      path10.push(frame.node);
+      path11.push(frame.node);
     }
     const { done, value: neighbor } = frame.neighbors.next();
     if (done) {
       stack.pop();
-      path10.pop();
+      path11.pop();
       inStack.delete(frame.node);
       visited.add(frame.node);
     } else {
-      handleCycleNeighbor(neighbor, stack, path10, inStack, visited, acc, graph);
+      handleCycleNeighbor(neighbor, stack, path11, inStack, visited, acc, graph);
     }
   }
 }
-function handleCycleNeighbor(neighbor, stack, path10, inStack, visited, acc, graph) {
+function handleCycleNeighbor(neighbor, stack, path11, inStack, visited, acc, graph) {
   if (inStack.has(neighbor)) {
-    recordCycle(neighbor, path10, acc);
+    recordCycle(neighbor, path11, acc);
   } else if (!visited.has(neighbor)) {
     stack.push(mkFrame(neighbor, graph));
   }
 }
-function recordCycle(cycleStart, path10, acc) {
-  const idx = path10.indexOf(cycleStart);
+function recordCycle(cycleStart, path11, acc) {
+  const idx = path11.indexOf(cycleStart);
   if (idx === -1) return;
-  const cycle = normalizeCycle(path10.slice(idx));
+  const cycle = normalizeCycle(path11.slice(idx));
   const key = cycle.join("\0");
   if (!acc.seenKeys.has(key)) {
     acc.seenKeys.add(key);
@@ -534,7 +611,7 @@ function runDeadCodeModule(project, graph, entryPoints, rootDir) {
     chains.set(root, chain);
   }
   const liveFiles = new Set(allFiles.filter((f) => !deadSet.has(f)));
-  const deadExports = findDeadExports(project, liveFiles);
+  const deadExports = findDeadExports(project, liveFiles, rootDir);
   const report = buildDeadCodeReport(
     safeToDelete,
     transitivelyDead,
@@ -569,10 +646,12 @@ function collectTransitiveChain(root, graph, deadSet) {
   }
   return chain;
 }
-function findDeadExports(project, liveFiles) {
+function findDeadExports(project, liveFiles, rootDir) {
   const importedNames = buildImportedNameMap(project, liveFiles);
   const dead = [];
   for (const filePath of liveFiles) {
+    if (isFrameworkFile(filePath, rootDir)) continue;
+    if (isConventionRoutedSourceFile(filePath, rootDir)) continue;
     collectFileDeadExports(filePath, project, importedNames, dead);
   }
   return dead;
@@ -646,7 +725,7 @@ function buildDeadCodeReport(safeToDelete, transitivelyDead, chains, deadExports
   if (deadExports.length > 0) {
     lines.push(
       "\u2500\u2500 DEAD EXPORTS \u2500\u2500",
-      "(Exported but never imported by any other file)",
+      "(Exported but never imported by any other file; pages/routes omitted)",
       ""
     );
     for (const entry of deadExports) {
@@ -1284,21 +1363,138 @@ function buildAssetReport(unused, totalAssets, rootDir) {
   return lines.join("\n");
 }
 
+// src/core/report-parser.ts
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+function parseDeadCodeReportFile(reportPath, rootDir) {
+  if (!import_node_fs9.default.existsSync(reportPath)) return [];
+  const content = import_node_fs9.default.readFileSync(reportPath, "utf-8");
+  return parseDeadCodeReportContent(content, rootDir);
+}
+function parseDeadCodeReportContent(content, rootDir) {
+  const lines = content.split(/\r?\n/);
+  const paths = [];
+  const legacyRe = /^DEAD FILE —\s+(.+)$/;
+  let legacyMode = content.includes("DEAD FILE \u2014") && content.includes("Dead files :");
+  if (legacyMode) {
+    for (const line of lines) {
+      const m = legacyRe.exec(line.trim());
+      if (m) paths.push(import_node_path9.default.resolve(rootDir, m[1].trim()));
+    }
+    return [...new Set(paths)];
+  }
+  let section = "none";
+  const fileLineRe = /^\s{2}(.+?)\s+\(~[\d.]+\s+KB\)\s*$/;
+  for (const line of lines) {
+    if (line.includes("\u2500\u2500 SAFE TO DELETE \u2500\u2500")) {
+      section = "safe";
+      continue;
+    }
+    if (line.includes("\u2500\u2500 TRANSITIVELY DEAD \u2500\u2500")) {
+      section = "transitive";
+      continue;
+    }
+    if (line.includes("\u2500\u2500 DEAD EXPORTS \u2500\u2500")) {
+      section = "none";
+      continue;
+    }
+    if (line.startsWith("\u2500\u2500 ") && line.includes("\u2500\u2500")) {
+      if (section !== "none" && !line.includes("SAFE TO DELETE") && !line.includes("TRANSITIVELY DEAD")) {
+        section = "none";
+      }
+      continue;
+    }
+    if (section === "safe" || section === "transitive") {
+      if (line.includes("\u2514\u2500") || line.includes("also makes dead")) continue;
+      const m = fileLineRe.exec(line);
+      if (m) {
+        const rel = m[1].trim();
+        if (rel && !rel.startsWith("(")) {
+          paths.push(import_node_path9.default.resolve(rootDir, rel));
+        }
+      }
+    }
+  }
+  return [...new Set(paths)];
+}
+function countDeadExportsInReport(content) {
+  let section = false;
+  let n = 0;
+  for (const line of content.split(/\r?\n/)) {
+    if (line.includes("\u2500\u2500 DEAD EXPORTS \u2500\u2500")) {
+      section = true;
+      continue;
+    }
+    if (section && line.startsWith("\u2500\u2500 ") && line.includes("\u2500\u2500")) break;
+    if (section && /\s→\s.+\[line \d+\]/.test(line)) n++;
+  }
+  return n;
+}
+function parseDeadCodeReportSummary(content) {
+  const safe = content.match(/Safe to delete\s*:\s*(\d+)/);
+  const trans = content.match(/Transitively dead\s*:\s*(\d+)/);
+  const exp = content.match(/Dead exports\s*:\s*(\d+)/);
+  const rec = content.match(/Recoverable\s*:\s*(~[\d.]+\s*KB)/i);
+  if (!safe || !trans || !exp) return null;
+  return {
+    safeToDelete: Number(safe[1]),
+    transitivelyDead: Number(trans[1]),
+    deadExports: Number(exp[1]),
+    recoverableDisplay: rec ? rec[1].trim() : "~0.0 KB"
+  };
+}
+function parseAssetsReportFile(reportPath, rootDir) {
+  if (!import_node_fs9.default.existsSync(reportPath)) return [];
+  const content = import_node_fs9.default.readFileSync(reportPath, "utf-8");
+  return parseAssetsReportContent(content, rootDir);
+}
+function parseAssetsReportContent(content, rootDir) {
+  const lines = content.split(/\r?\n/);
+  const paths = [];
+  let inTable = false;
+  let headerSeen = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("## Unused Assets")) {
+      inTable = true;
+      headerSeen = false;
+      continue;
+    }
+    if (inTable && trimmed.startsWith("## ")) {
+      break;
+    }
+    if (!inTable) continue;
+    if (trimmed.startsWith("|") && trimmed.includes("---")) {
+      headerSeen = true;
+      continue;
+    }
+    if (!headerSeen || !trimmed.startsWith("|")) continue;
+    const cells = trimmed.split("|").map((c) => c.trim()).filter(Boolean);
+    if (cells.length >= 1) {
+      const rel = cells[0];
+      if (rel.toLowerCase() === "asset") continue;
+      if (rel.includes("---")) continue;
+      paths.push(import_node_path9.default.resolve(rootDir, rel));
+    }
+  }
+  return [...new Set(paths)];
+}
+
 // src/cli.ts
 var import_meta = {};
 function readPkgVersion() {
   try {
     if (typeof import_meta !== "undefined" && import_meta.url) {
-      const dir = import_node_path9.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-      const pkgPath = import_node_path9.default.resolve(dir, "..", "package.json");
-      return JSON.parse(import_node_fs9.default.readFileSync(pkgPath, "utf-8")).version;
+      const dir = import_node_path10.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+      const pkgPath = import_node_path10.default.resolve(dir, "..", "package.json");
+      return JSON.parse(import_node_fs10.default.readFileSync(pkgPath, "utf-8")).version;
     }
   } catch {
   }
   try {
     const dir = globalThis.__dirname ?? __dirname;
-    const pkgPath = import_node_path9.default.resolve(dir, "..", "package.json");
-    return JSON.parse(import_node_fs9.default.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = import_node_path10.default.resolve(dir, "..", "package.json");
+    return JSON.parse(import_node_fs10.default.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return "0.0.0";
   }
@@ -1311,11 +1507,14 @@ program.name("prunify").description("npm run clean. ship with confidence.").vers
   "Glob pattern to ignore (repeatable)",
   (val, acc) => [...acc, val],
   []
-).option("--out <path>", "Output directory for reports").option("--html", "Also generate code_health.html").option("--delete", "Prompt to delete dead files after analysis").option("--ci", "CI mode: exit 1 if issues found, no interactive prompts").action(main);
+).option("--out <path>", "Output directory for reports").option("--html", "Also generate code_health.html").option("--delete", "Delete dead files (uses prunify-reports/dead-code.txt if present, else runs analysis)").option(
+  "--delete-assets",
+  "Delete unused public assets (uses prunify-reports/assets.md if present, else runs asset scan)"
+).option("--ci", "CI mode: exit 1 if issues found, no interactive prompts").action(main);
 program.parse();
 async function main(opts) {
-  const rootDir = import_node_path9.default.resolve(opts.dir);
-  if (!import_node_fs9.default.existsSync(import_node_path9.default.join(rootDir, "package.json"))) {
+  const rootDir = import_node_path10.default.resolve(opts.dir);
+  if (!import_node_fs10.default.existsSync(import_node_path10.default.join(rootDir, "package.json"))) {
     console.error(import_chalk7.default.red(`\u2717  No package.json found in ${rootDir}`));
     console.error(import_chalk7.default.dim("   Use --dir <path> to point to your project root."));
     process.exit(1);
@@ -1324,65 +1523,124 @@ async function main(opts) {
   console.log();
   console.log(import_chalk7.default.bold.cyan("\u{1F9F9} prunify \u2014 npm run clean. ship with confidence."));
   console.log();
-  const parseSpinner = createSpinner(import_chalk7.default.cyan("Parsing codebase\u2026"));
-  const files = discoverFiles(rootDir, opts.ignore);
-  parseSpinner.succeed(import_chalk7.default.green(`Parsed codebase \u2014 ${files.length} file(s) found`));
-  const graphSpinner = createSpinner(import_chalk7.default.cyan("Building import graph\u2026"));
-  const project = buildProject(files);
-  const graph = buildGraph(files, (f) => {
-    const sf = project.getSourceFile(f);
-    return sf ? getImportsForFile(sf) : [];
-  });
-  const edgeCount = [...graph.values()].reduce((n, s) => n + s.size, 0);
-  graphSpinner.succeed(import_chalk7.default.green(`Import graph built \u2014 ${edgeCount} edge(s)`));
-  const packageJson = loadPackageJson2(rootDir);
-  const entryPoints = opts.entry ? [import_node_path9.default.resolve(opts.entry)] : findEntryPoints(rootDir, packageJson);
   const reportsDir = ensureReportsDir(rootDir, opts.out);
   appendToGitignore(rootDir);
+  const deadReportPath = import_node_path10.default.join(reportsDir, "dead-code.txt");
+  const assetsReportPath = import_node_path10.default.join(reportsDir, "assets.md");
+  const loadDeadFromCache = Boolean(opts.delete && import_node_fs10.default.existsSync(deadReportPath));
+  const loadAssetsFromCache = Boolean(opts.deleteAssets && import_node_fs10.default.existsSync(assetsReportPath));
+  let deadFilePaths = [];
+  let unusedAssetPaths = [];
+  if (loadDeadFromCache) {
+    deadFilePaths = parseDeadCodeReportFile(deadReportPath, rootDir);
+    console.log(
+      import_chalk7.default.cyan(
+        `  Using existing dead-code report (${deadFilePaths.length} file(s) to delete) \u2192 ${import_node_path10.default.relative(rootDir, deadReportPath)}`
+      )
+    );
+  }
+  if (loadAssetsFromCache) {
+    unusedAssetPaths = parseAssetsReportFile(assetsReportPath, rootDir);
+    console.log(
+      import_chalk7.default.cyan(
+        `  Using existing assets report (${unusedAssetPaths.length} asset(s) to delete) \u2192 ${import_node_path10.default.relative(rootDir, assetsReportPath)}`
+      )
+    );
+  }
+  const runDeadCode2 = !loadDeadFromCache && (modules.includes("dead-code") || Boolean(opts.delete));
+  const runCircular2 = modules.includes("circular");
+  const runAssets = !loadAssetsFromCache && (modules.includes("assets") || Boolean(opts.deleteAssets));
+  const needsGraph = runCircular2 || runDeadCode2;
+  let files = [];
+  let project;
+  let graph;
+  let entryPoints = [];
+  if (needsGraph) {
+    const parseSpinner = createSpinner(import_chalk7.default.cyan("Parsing codebase\u2026"));
+    files = discoverFiles(rootDir, opts.ignore);
+    parseSpinner.succeed(import_chalk7.default.green(`Parsed codebase \u2014 ${files.length} file(s) found`));
+    const graphSpinner = createSpinner(import_chalk7.default.cyan("Building import graph\u2026"));
+    project = buildProject(files);
+    graph = buildGraph(files, (f) => {
+      const sf = project.getSourceFile(f);
+      return sf ? getImportsForFile(sf) : [];
+    });
+    const edgeCount = [...graph.values()].reduce((n, s) => n + s.size, 0);
+    graphSpinner.succeed(import_chalk7.default.green(`Import graph built \u2014 ${edgeCount} edge(s)`));
+    const packageJson = loadPackageJson2(rootDir);
+    entryPoints = opts.entry ? [import_node_path10.default.resolve(opts.entry)] : findEntryPoints(rootDir, packageJson);
+  }
   console.log();
-  let deadFileCount = 0;
+  let deadSafeCount = 0;
+  let deadTransitiveCount = 0;
+  let deadExportsCount = 0;
+  let deadRecoverDisplay = "~0.0 KB";
   let dupeCount = 0;
   let unusedPkgCount = 0;
   let circularCount = 0;
   let unusedAssetCount = 0;
-  let deadReportFile = "";
   let dupesReportFile = "";
   let depsReportFile = "";
   let circularReportFile = "";
   let assetsReportFile = "";
-  const deadFilePaths = [];
-  if (modules.includes("dead-code")) {
+  if (loadDeadFromCache) {
+    try {
+      const raw = import_node_fs10.default.readFileSync(deadReportPath, "utf-8");
+      const parsed = parseDeadCodeReportSummary(raw);
+      if (parsed) {
+        deadSafeCount = parsed.safeToDelete;
+        deadTransitiveCount = parsed.transitivelyDead;
+        deadExportsCount = parsed.deadExports;
+        deadRecoverDisplay = parsed.recoverableDisplay;
+      } else {
+        deadExportsCount = countDeadExportsInReport(raw);
+        deadSafeCount = deadFilePaths.length;
+        deadTransitiveCount = 0;
+        deadRecoverDisplay = "\u2014";
+      }
+    } catch {
+      deadSafeCount = deadFilePaths.length;
+    }
+  }
+  if (loadAssetsFromCache) {
+    assetsReportFile = "assets.md";
+    unusedAssetCount = unusedAssetPaths.length;
+  }
+  if (runDeadCode2) {
     const spinner = createSpinner(import_chalk7.default.cyan("Analysing dead code\u2026"));
     const result = runDeadCodeModule(project, graph, entryPoints, rootDir);
-    deadFileCount = result.safeToDelete.length + result.transitivelyDead.length + result.deadExports.length;
-    deadFilePaths.push(...result.safeToDelete, ...result.transitivelyDead);
+    deadFilePaths = [...result.safeToDelete, ...result.transitivelyDead];
+    deadSafeCount = result.safeToDelete.length;
+    deadTransitiveCount = result.transitivelyDead.length;
+    deadExportsCount = result.deadExports.length;
+    const recoverBytes = deadFilePaths.reduce((sum, f) => sum + getFileSize(f), 0);
+    deadRecoverDisplay = `~${(recoverBytes / 1024).toFixed(1)} KB`;
     spinner.succeed(
       import_chalk7.default.green(
         `Dead code analysis complete \u2014 ${result.safeToDelete.length} safe to delete, ${result.transitivelyDead.length} transitively dead, ${result.deadExports.length} dead export(s)`
       )
     );
     if (result.report) {
-      deadReportFile = "dead-code.txt";
       const banner = `prunify ${PKG_VERSION} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 
 `;
-      writeReport(reportsDir, deadReportFile, banner + result.report);
+      writeReport(reportsDir, "dead-code.txt", banner + result.report);
     }
   }
   if (modules.includes("dupes")) {
-    const outputPath = import_node_path9.default.join(reportsDir, "dupes.md");
+    const outputPath = import_node_path10.default.join(reportsDir, "dupes.md");
     const dupes = await runDupeFinder(rootDir, { output: outputPath });
     dupeCount = dupes.length;
     if (dupeCount > 0) dupesReportFile = "dupes.md";
   }
-  if (modules.includes("circular")) {
+  if (runCircular2) {
     const spinner = createSpinner(import_chalk7.default.cyan("Analysing circular imports\u2026"));
     const cycles = detectCycles(graph);
     circularCount = cycles.length;
     spinner.succeed(import_chalk7.default.green(`Circular import analysis complete \u2014 ${circularCount} cycle(s) found`));
     if (circularCount > 0) {
       circularReportFile = "circular.txt";
-      const rel = (p) => import_node_path9.default.relative(rootDir, p).replaceAll("\\", "/");
+      const rel = (p) => import_node_path10.default.relative(rootDir, p).replaceAll("\\", "/");
       const cycleLines = [
         "========================================",
         "  CIRCULAR DEPENDENCIES",
@@ -1407,36 +1665,49 @@ async function main(opts) {
     }
   }
   if (modules.includes("deps")) {
-    const outputPath = import_node_path9.default.join(reportsDir, "deps.md");
+    const outputPath = import_node_path10.default.join(reportsDir, "deps.md");
     const issues = await runDepCheck({ cwd: rootDir, output: outputPath });
     unusedPkgCount = issues.filter((i) => i.type === "unused").length;
     if (issues.length > 0) depsReportFile = "deps.md";
   }
-  if (modules.includes("assets")) {
-    const outputPath = import_node_path9.default.join(reportsDir, "assets.md");
+  if (runAssets) {
+    const outputPath = import_node_path10.default.join(reportsDir, "assets.md");
     const unusedAssets = await runAssetCheck(rootDir, { output: outputPath });
+    unusedAssetPaths = unusedAssets.map((a) => a.filePath);
     unusedAssetCount = unusedAssets.length;
     if (unusedAssetCount > 0) assetsReportFile = "assets.md";
   }
   if (modules.includes("health")) {
-    const outputPath = import_node_path9.default.join(reportsDir, "health-report.md");
+    const outputPath = import_node_path10.default.join(reportsDir, "health-report.md");
     await runHealthReport(rootDir, { output: outputPath });
   }
   if (opts.html) {
-    const htmlPath = import_node_path9.default.join(reportsDir, "code_health.html");
+    const htmlPath = import_node_path10.default.join(reportsDir, "code_health.html");
     writeHtmlReport(htmlPath, rootDir, deadFilePaths, circularCount, dupeCount, unusedPkgCount);
     console.log(import_chalk7.default.cyan(`  HTML report written to ${htmlPath}`));
   }
   console.log();
   console.log(import_chalk7.default.bold("Summary"));
   console.log();
+  const fmt = (n) => n > 0 ? import_chalk7.default.yellow(String(n)) : import_chalk7.default.green("0");
+  const showDeadSummary = modules.includes("dead-code") || Boolean(opts.delete) || loadDeadFromCache || runDeadCode2;
+  if (showDeadSummary) {
+    const recoverKb = parseFloat(deadRecoverDisplay.replace(/[^\d.]/g, "")) || 0;
+    const recoverCh = deadRecoverDisplay === "\u2014" ? import_chalk7.default.dim("\u2014") : recoverKb > 0 ? import_chalk7.default.yellow(deadRecoverDisplay) : import_chalk7.default.green(deadRecoverDisplay);
+    console.log(import_chalk7.default.dim("========================================"));
+    console.log(import_chalk7.default.dim("  DEAD CODE REPORT"));
+    console.log(import_chalk7.default.dim("  Safe to delete     : ") + fmt(deadSafeCount));
+    console.log(import_chalk7.default.dim("  Transitively dead  : ") + fmt(deadTransitiveCount));
+    console.log(import_chalk7.default.dim("  Dead exports       : ") + fmt(deadExportsCount));
+    console.log(import_chalk7.default.dim("  Recoverable        : ") + recoverCh);
+    console.log(import_chalk7.default.dim("========================================"));
+    console.log();
+  }
   const table = new import_cli_table36.default({
     head: [import_chalk7.default.bold("Check"), import_chalk7.default.bold("Found"), import_chalk7.default.bold("Output File")],
     style: { head: [], border: [] }
   });
-  const fmt = (n) => n > 0 ? import_chalk7.default.yellow(String(n)) : import_chalk7.default.green("0");
   table.push(
-    ["Dead Code (files + exports)", fmt(deadFileCount), deadReportFile || "\u2014"],
     ["Circular Dependencies", fmt(circularCount), circularReportFile || "\u2014"],
     ["Duplicate Clusters", fmt(dupeCount), dupesReportFile || "\u2014"],
     ["Unused Packages", fmt(unusedPkgCount), depsReportFile || "\u2014"],
@@ -1445,25 +1716,76 @@ async function main(opts) {
   console.log(table.toString());
   console.log();
   if (opts.delete && deadFilePaths.length > 0) {
-    console.log(import_chalk7.default.yellow(`Dead files (${deadFilePaths.length}):`));
+    console.log(import_chalk7.default.yellow(`Dead code files to delete (${deadFilePaths.length}):`));
     for (const f of deadFilePaths) {
-      console.log(import_chalk7.default.dim(`  ${import_node_path9.default.relative(rootDir, f)}`));
+      console.log(import_chalk7.default.dim(`  ${import_node_path10.default.relative(rootDir, f)}`));
     }
     console.log();
     if (!opts.ci) {
-      const confirmed = await confirmPrompt("Delete these files? (y/N) ");
+      const confirmed = await confirmPrompt("Delete these dead code files? (y/N) ");
       if (confirmed) {
+        let removed = 0;
         for (const f of deadFilePaths) {
-          import_node_fs9.default.rmSync(f, { force: true });
+          try {
+            if (import_node_fs10.default.existsSync(f)) {
+              import_node_fs10.default.rmSync(f, { force: true });
+              removed++;
+            }
+          } catch {
+            console.log(import_chalk7.default.red(`  Failed to delete: ${import_node_path10.default.relative(rootDir, f)}`));
+          }
+        }
+        console.log(import_chalk7.default.green(`  Deleted ${removed} file(s).`));
+      } else {
+        console.log(import_chalk7.default.dim("  Skipped."));
+      }
+    }
+  } else if (opts.delete && deadFilePaths.length === 0) {
+    console.log(import_chalk7.default.dim("  --delete: no dead code files listed in report (nothing to delete)."));
+  }
+  if (opts.deleteAssets && unusedAssetPaths.length > 0) {
+    const publicDir = import_node_path10.default.join(rootDir, "public");
+    const safePaths = unusedAssetPaths.filter((p) => {
+      const norm = import_node_path10.default.normalize(p);
+      return norm.startsWith(import_node_path10.default.normalize(publicDir + import_node_path10.default.sep));
+    });
+    if (safePaths.length !== unusedAssetPaths.length) {
+      console.log(
+        import_chalk7.default.yellow(
+          `  Warning: skipped ${unusedAssetPaths.length - safePaths.length} path(s) outside public/`
+        )
+      );
+    }
+    console.log(import_chalk7.default.yellow(`Unused assets to delete (${safePaths.length}):`));
+    for (const f of safePaths) {
+      console.log(import_chalk7.default.dim(`  ${import_node_path10.default.relative(rootDir, f)}`));
+    }
+    console.log();
+    if (!opts.ci) {
+      const confirmed = await confirmPrompt("Delete these unused assets? (y/N) ");
+      if (confirmed) {
+        let removed = 0;
+        for (const f of safePaths) {
+          try {
+            if (import_node_fs10.default.existsSync(f)) {
+              import_node_fs10.default.rmSync(f, { force: true });
+              removed++;
+            }
+          } catch {
+            console.log(import_chalk7.default.red(`  Failed to delete: ${import_node_path10.default.relative(rootDir, f)}`));
+          }
         }
-        console.log(import_chalk7.default.green(`  Deleted ${deadFilePaths.length} file(s).`));
+        console.log(import_chalk7.default.green(`  Deleted ${removed} asset file(s).`));
       } else {
         console.log(import_chalk7.default.dim("  Skipped."));
       }
     }
+  } else if (opts.deleteAssets && unusedAssetPaths.length === 0) {
+    console.log(import_chalk7.default.dim("  --delete-assets: no unused assets in report (nothing to delete)."));
   }
   if (opts.ci) {
-    const hasIssues = deadFileCount > 0 || dupeCount > 0 || unusedPkgCount > 0 || circularCount > 0 || unusedAssetCount > 0;
+    const deadIssueCount = deadSafeCount + deadTransitiveCount + deadExportsCount;
+    const hasIssues = deadIssueCount > 0 || dupeCount > 0 || unusedPkgCount > 0 || circularCount > 0 || unusedAssetCount > 0;
     if (hasIssues) process.exit(1);
   }
 }
@@ -1474,7 +1796,7 @@ function resolveModules(only) {
 }
 function loadPackageJson2(dir) {
   try {
-    return JSON.parse(import_node_fs9.default.readFileSync(import_node_path9.default.join(dir, "package.json"), "utf-8"));
+    return JSON.parse(import_node_fs10.default.readFileSync(import_node_path10.default.join(dir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -1495,7 +1817,7 @@ function writeHtmlReport(outputPath, rootDir, deadFiles, circularCount, dupeCoun
     ["Circular Dependencies", String(circularCount)],
     ["Unused Packages", String(unusedPkgCount)]
   ].map(([label, val]) => `    <tr><td>${label}</td><td>${val}</td></tr>`).join("\n");
-  const deadList = deadFiles.length > 0 ? `<ul>${deadFiles.map((f) => `<li>${import_node_path9.default.relative(rootDir, f)}</li>`).join("")}</ul>` : "<p>None</p>";
+  const deadList = deadFiles.length > 0 ? `<ul>${deadFiles.map((f) => `<li>${import_node_path10.default.relative(rootDir, f)}</li>`).join("")}</ul>` : "<p>None</p>";
   const html = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -1522,7 +1844,7 @@ ${rows}
   ${deadList}
 </body>
 </html>`;
-  import_node_fs9.default.mkdirSync(import_node_path9.default.dirname(outputPath), { recursive: true });
-  import_node_fs9.default.writeFileSync(outputPath, html, "utf-8");
+  import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(outputPath), { recursive: true });
+  import_node_fs10.default.writeFileSync(outputPath, html, "utf-8");
 }
 //# sourceMappingURL=cli.cjs.map