prunify 0.1.1 → 0.1.4

package/dist/cli.js

@@ -2,10 +2,10 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk6 from "chalk";
-import Table5 from "cli-table3";
-import fs8 from "fs";
-import path8 from "path";
+import chalk7 from "chalk";
+import Table6 from "cli-table3";
+import fs9 from "fs";
+import path9 from "path";
 import { fileURLToPath } from "url";
 import readline from "readline";
 
@@ -57,7 +57,14 @@ var DEFAULT_IGNORE = [
   "coverage",
   "coverage/**",
   "**/*.test.ts",
+  "**/*.test.tsx",
+  "**/*.test.js",
+  "**/*.test.jsx",
   "**/*.spec.ts",
+  "**/*.spec.tsx",
+  "**/*.spec.js",
+  "**/*.spec.jsx",
+  "**/*.stories.ts",
   "**/*.stories.tsx",
   "**/*.d.ts"
 ];
@@ -202,45 +209,22 @@ function buildGraph(files, getImports) {
 function findEntryPoints(rootDir, packageJson) {
   const entries = [
     ...resolveNextJsEntries(rootDir),
-    ...resolvePkgFieldEntries(rootDir, packageJson)
+    ...resolveFileBrowserEntries(rootDir),
+    ...resolvePkgFieldEntries(rootDir, packageJson),
+    ...resolveFallbackEntries(rootDir)
   ];
-  if (entries.length === 0) {
-    const fallback = resolveFallbackEntry(rootDir);
-    if (fallback) entries.push(fallback);
-  }
   return [...new Set(entries)];
 }
-function runDFS(graph, entryPoints) {
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [...entryPoints];
-  let node;
-  while ((node = stack.pop()) !== void 0) {
-    if (visited.has(node)) continue;
-    visited.add(node);
-    for (const neighbor of graph.get(node) ?? []) {
-      if (!visited.has(neighbor)) stack.push(neighbor);
-    }
-  }
-  return visited;
-}
-function findDeadChains(graph, deadFiles) {
-  const reverseGraph = buildReverseGraph(graph);
-  const result = /* @__PURE__ */ new Map();
-  for (const deadRoot of deadFiles) {
-    result.set(deadRoot, dfsDeadChain(deadRoot, graph, deadFiles, reverseGraph));
-  }
-  return result;
-}
 function detectCycles(graph) {
   const cycles = [];
   const seenKeys = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const inStack = /* @__PURE__ */ new Set();
-  const path9 = [];
+  const path10 = [];
   const acc = { seenKeys, cycles };
   for (const start of graph.keys()) {
     if (!visited.has(start)) {
-      dfsForCycles(start, graph, visited, inStack, path9, acc);
+      dfsForCycles(start, graph, visited, inStack, path10, acc);
     }
   }
   return cycles;
@@ -249,12 +233,21 @@ function resolveNextJsEntries(rootDir) {
   const isNext = fs3.existsSync(path3.join(rootDir, "next.config.js")) || fs3.existsSync(path3.join(rootDir, "next.config.ts")) || fs3.existsSync(path3.join(rootDir, "next.config.mjs"));
   if (!isNext) return [];
   const entries = [];
-  for (const dir of ["pages", "app"]) {
+  for (const dir of ["pages", "app", "src/pages", "src/app"]) {
     const dirPath = path3.join(rootDir, dir);
     if (fs3.existsSync(dirPath)) entries.push(...collectSourceFiles(dirPath));
   }
   return entries;
 }
+function resolveFileBrowserEntries(rootDir) {
+  const PAGE_DIRS = ["src/pages", "src/routes", "src/views", "src/screens"];
+  const entries = [];
+  for (const rel of PAGE_DIRS) {
+    const dirPath = path3.join(rootDir, rel);
+    if (fs3.existsSync(dirPath)) entries.push(...collectSourceFiles(dirPath));
+  }
+  return entries;
+}
 function resolvePkgFieldEntries(rootDir, packageJson) {
   const entries = [];
   for (const field of ["main", "module"]) {
@@ -265,18 +258,31 @@ function resolvePkgFieldEntries(rootDir, packageJson) {
   }
   return entries;
 }
-function resolveFallbackEntry(rootDir) {
-  const fallbacks = ["src/main.ts", "src/main.tsx", "src/index.ts", "src/index.tsx"];
-  for (const rel of fallbacks) {
-    const abs = path3.join(rootDir, rel);
-    if (fs3.existsSync(abs)) return abs;
-  }
-  return void 0;
+function resolveFallbackEntries(rootDir) {
+  const candidates = [
+    "src/main.ts",
+    "src/main.tsx",
+    "src/main.js",
+    "src/main.jsx",
+    "src/index.ts",
+    "src/index.tsx",
+    "src/index.js",
+    "src/index.jsx",
+    "src/App.ts",
+    "src/App.tsx",
+    "src/App.js",
+    "src/App.jsx",
+    "index.ts",
+    "index.tsx",
+    "index.js",
+    "index.jsx"
+  ];
+  return candidates.map((rel) => path3.join(rootDir, rel)).filter((abs) => fs3.existsSync(abs));
 }
 function mkFrame(node, graph) {
   return { node, neighbors: (graph.get(node) ?? /* @__PURE__ */ new Set()).values(), entered: false };
 }
-function dfsForCycles(start, graph, visited, inStack, path9, acc) {
+function dfsForCycles(start, graph, visited, inStack, path10, acc) {
   const stack = [mkFrame(start, graph)];
   while (stack.length > 0) {
     const frame = stack.at(-1);
@@ -288,57 +294,36 @@ function dfsForCycles(start, graph, visited, inStack, path9, acc) {
       }
       frame.entered = true;
       inStack.add(frame.node);
-      path9.push(frame.node);
+      path10.push(frame.node);
     }
     const { done, value: neighbor } = frame.neighbors.next();
     if (done) {
       stack.pop();
-      path9.pop();
+      path10.pop();
       inStack.delete(frame.node);
       visited.add(frame.node);
     } else {
-      handleCycleNeighbor(neighbor, stack, path9, inStack, visited, acc, graph);
+      handleCycleNeighbor(neighbor, stack, path10, inStack, visited, acc, graph);
     }
   }
 }
-function handleCycleNeighbor(neighbor, stack, path9, inStack, visited, acc, graph) {
+function handleCycleNeighbor(neighbor, stack, path10, inStack, visited, acc, graph) {
   if (inStack.has(neighbor)) {
-    recordCycle(neighbor, path9, acc);
+    recordCycle(neighbor, path10, acc);
   } else if (!visited.has(neighbor)) {
     stack.push(mkFrame(neighbor, graph));
   }
 }
-function recordCycle(cycleStart, path9, acc) {
-  const idx = path9.indexOf(cycleStart);
+function recordCycle(cycleStart, path10, acc) {
+  const idx = path10.indexOf(cycleStart);
   if (idx === -1) return;
-  const cycle = normalizeCycle(path9.slice(idx));
+  const cycle = normalizeCycle(path10.slice(idx));
   const key = cycle.join("\0");
   if (!acc.seenKeys.has(key)) {
     acc.seenKeys.add(key);
     acc.cycles.push(cycle);
   }
 }
-function dfsDeadChain(deadRoot, graph, deadFiles, reverseGraph) {
-  const chain = [];
-  const visited = /* @__PURE__ */ new Set();
-  const stack = [...graph.get(deadRoot) ?? []];
-  let node;
-  while ((node = stack.pop()) !== void 0) {
-    if (visited.has(node) || node === deadRoot) continue;
-    visited.add(node);
-    if (deadFiles.has(node) || isOnlyImportedByDead(node, deadFiles, reverseGraph)) {
-      chain.push(node);
-      for (const next of graph.get(node) ?? []) {
-        if (!visited.has(next)) stack.push(next);
-      }
-    }
-  }
-  return chain;
-}
-function isOnlyImportedByDead(file, deadFiles, reverseGraph) {
-  const importers = reverseGraph.get(file) ?? /* @__PURE__ */ new Set();
-  return importers.size === 0 || [...importers].every((imp) => deadFiles.has(imp));
-}
 function buildReverseGraph(graph) {
   const rev = /* @__PURE__ */ new Map();
   for (const [file] of graph) {
@@ -465,16 +450,101 @@ function ensureDir(dir) {
 }
 
 // src/modules/dead-code.ts
+var FRAMEWORK_FILE_PATTERNS = [
+  /^next\.config\.(js|ts|mjs|cjs)$/,
+  /^middleware\.(ts|js)$/,
+  /^instrumentation\.(ts|js)$/,
+  /^tailwind\.config\.(js|ts|mjs|cjs)$/,
+  /^postcss\.config\.(js|ts|mjs|cjs)$/,
+  /^jest\.config\.(js|ts|mjs|cjs)$/,
+  /^vitest\.config\.(js|ts|mjs|cjs)$/,
+  /^vite\.config\.(js|ts|mjs|cjs)$/,
+  /^webpack\.config\.(js|ts|mjs|cjs)$/,
+  /^babel\.config\.(js|ts|cjs|mjs|json)$/,
+  /^\.babelrc\.(js|cjs)$/,
+  /^\.eslintrc\.(js|cjs)$/,
+  /^eslint\.config\.(js|ts|mjs|cjs)$/,
+  /^prettier\.config\.(js|ts|mjs|cjs)$/,
+  /^tsup\.config\.(ts|js)$/,
+  /^rollup\.config\.(js|ts|mjs)$/,
+  /^esbuild\.config\.(js|ts|mjs)$/,
+  /^commitlint\.config\.(js|ts)$/,
+  /^lint-staged\.config\.(js|ts|mjs|cjs)$/,
+  /^sentry\.(client|server|edge)\.config\.(ts|js)$/
+];
+function isFrameworkFile(filePath, rootDir) {
+  const rel = path5.relative(rootDir, filePath);
+  const basename = path5.basename(rel);
+  return FRAMEWORK_FILE_PATTERNS.some((re) => re.test(basename));
+}
 function runDeadCodeModule(project, graph, entryPoints, rootDir) {
   const allFiles = [...graph.keys()];
-  const effectiveEntries = entryPoints.length > 0 ? entryPoints : allFiles.slice(0, 1);
-  const liveFiles = runDFS(graph, effectiveEntries);
-  const deadFiles = allFiles.filter((f) => !liveFiles.has(f));
-  const deadSet = new Set(deadFiles);
-  const chains = findDeadChains(graph, deadSet);
+  const entrySet = new Set(entryPoints);
+  const reverseGraph = buildReverseGraph(graph);
+  const excludedFiles = /* @__PURE__ */ new Set();
+  for (const file of allFiles) {
+    if (isFrameworkFile(file, rootDir)) excludedFiles.add(file);
+  }
+  const safeToDelete = allFiles.filter((f) => {
+    if (entrySet.has(f) || excludedFiles.has(f)) return false;
+    const importers = reverseGraph.get(f);
+    return !importers || importers.size === 0;
+  });
+  const deadSet = new Set(safeToDelete);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const file of allFiles) {
+      if (deadSet.has(file) || entrySet.has(file) || excludedFiles.has(file)) continue;
+      const importers = reverseGraph.get(file);
+      if (!importers || importers.size === 0) continue;
+      if ([...importers].every((imp) => deadSet.has(imp))) {
+        deadSet.add(file);
+        changed = true;
+      }
+    }
+  }
+  const transitivelyDead = [...deadSet].filter((f) => !safeToDelete.includes(f));
+  const chains = /* @__PURE__ */ new Map();
+  for (const root of safeToDelete) {
+    const chain = collectTransitiveChain(root, graph, deadSet);
+    chains.set(root, chain);
+  }
+  const liveFiles = new Set(allFiles.filter((f) => !deadSet.has(f)));
   const deadExports = findDeadExports(project, liveFiles);
-  const report = buildDeadCodeReport(deadFiles, chains, deadExports, rootDir);
-  return { deadFiles, liveFiles, chains, deadExports, report };
+  const report = buildDeadCodeReport(
+    safeToDelete,
+    transitivelyDead,
+    chains,
+    deadExports,
+    rootDir
+  );
+  return {
+    safeToDelete,
+    transitivelyDead,
+    deadFiles: [...deadSet],
+    liveFiles,
+    chains,
+    deadExports,
+    report
+  };
+}
+function collectTransitiveChain(root, graph, deadSet) {
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [...graph.get(root) ?? []];
+  let node;
+  while ((node = stack.pop()) !== void 0) {
+    if (visited.has(node) || node === root) continue;
+    visited.add(node);
+    if (deadSet.has(node)) {
+      chain.push(node);
+      for (const next of graph.get(node) ?? []) {
+        if (!visited.has(next)) stack.push(next);
+      }
+    }
+  }
+  return chain;
 }
 function findDeadExports(project, liveFiles) {
   const importedNames = buildImportedNameMap(project, liveFiles);
@@ -507,51 +577,61 @@ function getFileSize(filePath) {
     return 0;
   }
 }
-function buildDeadCodeReport(deadFiles, chains, deadExports, rootDir) {
+function buildDeadCodeReport(safeToDelete, transitivelyDead, chains, deadExports, rootDir) {
   const rel = (p) => path5.relative(rootDir, p).replaceAll("\\", "/");
-  const totalBytes = deadFiles.reduce((sum, f) => {
-    const chain = chains.get(f) ?? [];
-    return sum + getFileSize(f) + chain.reduce((s, c) => s + getFileSize(c), 0);
-  }, 0);
+  const allDeadFiles = [...safeToDelete, ...transitivelyDead];
+  const totalBytes = allDeadFiles.reduce((sum, f) => sum + getFileSize(f), 0);
   const totalKb = (totalBytes / 1024).toFixed(1);
   const lines = [
     "========================================",
     "  DEAD CODE REPORT",
-    `  Dead files : ${deadFiles.length}`,
-    `  Dead exports: ${deadExports.length}`,
-    `  Recoverable : ~${totalKb} KB`,
+    `  Safe to delete     : ${safeToDelete.length}`,
+    `  Transitively dead  : ${transitivelyDead.length}`,
+    `  Dead exports       : ${deadExports.length}`,
+    `  Recoverable        : ~${totalKb} KB`,
     "========================================",
     ""
   ];
-  if (deadFiles.length > 0) {
-    lines.push("\u2500\u2500 DEAD FILES \u2500\u2500", "");
-    for (const filePath of deadFiles) {
+  if (safeToDelete.length > 0) {
+    lines.push(
+      "\u2500\u2500 SAFE TO DELETE \u2500\u2500",
+      "(These files are not imported by any other file in the codebase)",
+      ""
+    );
+    for (const filePath of safeToDelete) {
       const chain = chains.get(filePath) ?? [];
-      const allFiles = [filePath, ...chain];
-      const sizeBytes = allFiles.reduce((s, f) => s + getFileSize(f), 0);
-      const sizeKb = (sizeBytes / 1024).toFixed(1);
-      const chainStr = chain.length > 0 ? [rel(filePath), ...chain.map(rel)].join(" \u2192 ") : rel(filePath);
-      const plural = allFiles.length === 1 ? "" : "s";
-      lines.push(
-        `DEAD FILE \u2014 ${rel(filePath)}`,
-        `Reason: Not imported anywhere in the codebase`,
-        `Chain: ${chainStr}`,
-        `Size: ~${sizeKb} KB removable across ${allFiles.length} file${plural}`,
-        `Action: Safe to delete all ${allFiles.length} file${plural}`,
-        ""
-      );
+      const sizeKb = (getFileSize(filePath) / 1024).toFixed(1);
+      lines.push(`  ${rel(filePath)}  (~${sizeKb} KB)`);
+      if (chain.length > 0) {
+        lines.push(`    \u2514\u2500 also makes dead: ${chain.map(rel).join(", ")}`);
+      }
+    }
+    lines.push("");
+  }
+  if (transitivelyDead.length > 0) {
+    lines.push(
+      "\u2500\u2500 TRANSITIVELY DEAD \u2500\u2500",
+      "(These files are only imported by dead files \u2014 they become orphaned too)",
+      ""
+    );
+    for (const filePath of transitivelyDead) {
+      const sizeKb = (getFileSize(filePath) / 1024).toFixed(1);
+      lines.push(`  ${rel(filePath)}  (~${sizeKb} KB)`);
     }
+    lines.push("");
   }
   if (deadExports.length > 0) {
-    lines.push("\u2500\u2500 DEAD EXPORTS \u2500\u2500", "");
+    lines.push(
+      "\u2500\u2500 DEAD EXPORTS \u2500\u2500",
+      "(Exported but never imported by any other file)",
+      ""
+    );
     for (const entry of deadExports) {
       lines.push(
-        `DEAD EXPORT \u2014 ${rel(entry.filePath)} \u2192 ${entry.exportName}() [line ${entry.line}]`,
-        `Reason: Exported but never imported`,
-        `Action: Remove the export (file itself is still live)`,
-        ""
+        `  ${rel(entry.filePath)} \u2192 ${entry.exportName} [line ${entry.line}]`
       );
     }
+    lines.push("");
   }
   return lines.join("\n");
 }
@@ -568,7 +648,8 @@ async function runDeadCode(dir, opts) {
     const entries = findEntryPoints(dir, packageJson);
     const result = runDeadCodeModule(project, graph, entries, dir);
     const dead = [
-      ...result.deadFiles.map((f) => ({ file: f, exportName: "(entire file)" })),
+      ...result.safeToDelete.map((f) => ({ file: f, exportName: "(entire file \u2014 safe to delete)" })),
+      ...result.transitivelyDead.map((f) => ({ file: f, exportName: "(entire file \u2014 transitively dead)" })),
       ...result.deadExports.map((e) => ({ file: e.filePath, exportName: e.exportName }))
     ];
     spinner.succeed(chalk.green(`Dead code scan complete \u2014 ${dead.length} item(s) found`));
@@ -644,7 +725,11 @@ function writeDeadOutput(result, opts) {
   if (!opts.output) return;
   if (opts.json) {
     writeJson(
-      { deadFiles: result.deadFiles, deadExports: result.deadExports },
+      {
+        safeToDelete: result.safeToDelete,
+        transitivelyDead: result.transitivelyDead,
+        deadExports: result.deadExports
+      },
       opts.output
     );
     console.log(chalk.cyan(`  JSON written to ${opts.output}`));
@@ -653,16 +738,21 @@ function writeDeadOutput(result, opts) {
   writeMarkdown(
     {
       title: "Dead Code Report",
-      summary: `${result.deadFiles.length} dead file(s), ${result.deadExports.length} dead export(s)`,
+      summary: `${result.safeToDelete.length} safe to delete, ${result.transitivelyDead.length} transitively dead, ${result.deadExports.length} dead export(s)`,
       sections: [
         {
-          title: "Dead Files",
+          title: "Safe to Delete",
           headers: ["File", "Chain"],
-          rows: result.deadFiles.map((f) => [
+          rows: result.safeToDelete.map((f) => [
             f,
             (result.chains.get(f) ?? []).join(" \u2192 ") || "\u2014"
           ])
         },
+        {
+          title: "Transitively Dead",
+          headers: ["File"],
+          rows: result.transitivelyDead.map((f) => [f])
+        },
         {
           title: "Dead Exports",
           headers: ["File", "Export", "Line"],
@@ -691,17 +781,30 @@ import {
 } from "ts-morph";
 
 // src/modules/dupe-finder.ts
+var MIN_BLOCK_CHARS = 120;
 async function runDupeFinder(dir, opts) {
-  const minLines = parseInt(opts.minLines ?? "5", 10);
+  const minLines = parseInt(opts.minLines ?? "15", 10);
   const spinner = ora3(chalk2.cyan(`Scanning for duplicate blocks (\u2265${minLines} lines)\u2026`)).start();
   try {
-    const files = glob(dir, ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], ["node_modules", "dist"]);
+    const files = glob(dir, ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], [
+      "node_modules",
+      "dist",
+      ".next",
+      "coverage",
+      "**/*.test.ts",
+      "**/*.test.tsx",
+      "**/*.spec.ts",
+      "**/*.spec.tsx",
+      "**/*.d.ts"
+    ]);
     const blockMap = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       const content = fs6.readFileSync(filePath, "utf-8");
       const lines = content.split("\n").map((l) => l.trim()).filter(Boolean);
       for (let i = 0; i <= lines.length - minLines; i++) {
         const block = lines.slice(i, i + minLines).join("\n");
+        const meaningfulChars = block.replace(/[\s{}();,]/g, "").length;
+        if (meaningfulChars < MIN_BLOCK_CHARS) continue;
         if (!blockMap.has(block)) blockMap.set(block, []);
         blockMap.get(block).push({ file: filePath, startLine: i + 1 });
       }
@@ -716,6 +819,8 @@ async function runDupeFinder(dir, opts) {
         });
       }
     }
+    dupes.sort((a, b) => b.occurrences.length - a.occurrences.length);
+    if (dupes.length > 200) dupes.splice(200);
     spinner.succeed(chalk2.green(`Duplicate scan complete \u2014 ${dupes.length} duplicate block(s) found`));
     if (dupes.length === 0) {
       console.log(chalk2.green("  No duplicate blocks detected."));
@@ -967,26 +1072,218 @@ async function runHealthReport(dir, opts) {
   );
 }
 
+// src/modules/assets.ts
+import fs8 from "fs";
+import path8 from "path";
+import ora6 from "ora";
+import chalk6 from "chalk";
+import Table5 from "cli-table3";
+var ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".bmp",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp4",
+  ".webm",
+  ".ogg",
+  ".mp3",
+  ".wav",
+  ".pdf"
+]);
+var SOURCE_PATTERNS2 = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.css",
+  "**/*.scss",
+  "**/*.sass",
+  "**/*.less",
+  "**/*.html",
+  "**/*.json"
+];
+var SOURCE_IGNORE = [
+  "node_modules",
+  "node_modules/**",
+  "dist",
+  "dist/**",
+  ".next",
+  ".next/**",
+  "coverage",
+  "coverage/**",
+  "public",
+  "public/**"
+];
+function runAssetCheckModule(rootDir) {
+  const publicDir = path8.join(rootDir, "public");
+  if (!fs8.existsSync(publicDir)) {
+    return { unusedAssets: [], totalAssets: 0, report: buildAssetReport([], 0, rootDir) };
+  }
+  const assets = collectAssets(publicDir);
+  if (assets.length === 0) {
+    return { unusedAssets: [], totalAssets: 0, report: buildAssetReport([], 0, rootDir) };
+  }
+  const sourceFiles = glob(rootDir, SOURCE_PATTERNS2, SOURCE_IGNORE);
+  const sourceContent = sourceFiles.reduce((acc, f) => {
+    try {
+      return acc + fs8.readFileSync(f, "utf-8") + "\n";
+    } catch {
+      return acc;
+    }
+  }, "");
+  const unused = [];
+  for (const assetAbs of assets) {
+    const fileName = path8.basename(assetAbs);
+    const relFromPublic = "/" + path8.relative(publicDir, assetAbs).replaceAll("\\", "/");
+    const referenced = sourceContent.includes(fileName) || sourceContent.includes(relFromPublic);
+    if (!referenced) {
+      unused.push({
+        filePath: assetAbs,
+        relativePath: path8.relative(rootDir, assetAbs).replaceAll("\\", "/"),
+        sizeBytes: getFileSize2(assetAbs)
+      });
+    }
+  }
+  const report = buildAssetReport(unused, assets.length, rootDir);
+  return { unusedAssets: unused, totalAssets: assets.length, report };
+}
+async function runAssetCheck(rootDir, opts) {
+  const publicDir = path8.join(rootDir, "public");
+  if (!fs8.existsSync(publicDir)) {
+    console.log(chalk6.dim("  No public/ folder found \u2014 skipping asset check"));
+    return [];
+  }
+  const spinner = ora6(chalk6.cyan("Scanning public/ for unused assets\u2026")).start();
+  try {
+    const result = runAssetCheckModule(rootDir);
+    spinner.succeed(
+      chalk6.green(
+        `Asset scan complete \u2014 ${result.unusedAssets.length} unused / ${result.totalAssets} total`
+      )
+    );
+    if (result.unusedAssets.length === 0) {
+      console.log(chalk6.green("  All public assets are referenced in source."));
+      return [];
+    }
+    const table = new Table5({ head: ["Asset", "Size"] });
+    for (const asset of result.unusedAssets) {
+      const kb = (asset.sizeBytes / 1024).toFixed(1);
+      table.push([chalk6.gray(asset.relativePath), `${kb} KB`]);
+    }
+    console.log(table.toString());
+    if (opts.output) {
+      writeMarkdown(
+        {
+          title: "Unused Assets Report",
+          summary: `${result.unusedAssets.length} unused asset(s) found in public/`,
+          sections: [
+            {
+              title: "Unused Assets",
+              headers: ["Asset", "Size (KB)"],
+              rows: result.unusedAssets.map((a) => [
+                a.relativePath,
+                (a.sizeBytes / 1024).toFixed(1)
+              ])
+            }
+          ],
+          generatedAt: /* @__PURE__ */ new Date()
+        },
+        opts.output
+      );
+      console.log(chalk6.cyan(`  Report written to ${opts.output}`));
+    }
+    return result.unusedAssets;
+  } catch (err) {
+    spinner.fail(chalk6.red("Asset scan failed"));
+    throw err;
+  }
+}
+function collectAssets(dir) {
+  const results = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = fs8.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path8.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && ASSET_EXTENSIONS.has(path8.extname(entry.name).toLowerCase())) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function getFileSize2(filePath) {
+  try {
+    return fs8.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function buildAssetReport(unused, totalAssets, rootDir) {
+  const totalBytes = unused.reduce((s, a) => s + a.sizeBytes, 0);
+  const totalKb = (totalBytes / 1024).toFixed(1);
+  const lines = [
+    "========================================",
+    "  UNUSED ASSETS REPORT",
+    `  Total assets   : ${totalAssets}`,
+    `  Unused assets  : ${unused.length}`,
+    `  Recoverable    : ~${totalKb} KB`,
+    "========================================",
+    ""
+  ];
+  if (unused.length === 0) {
+    lines.push("  All public assets are referenced in source.", "");
+    return lines.join("\n");
+  }
+  lines.push("\u2500\u2500 UNUSED ASSETS \u2500\u2500", "");
+  for (const asset of unused) {
+    lines.push(
+      `UNUSED \u2014 ${asset.relativePath}`,
+      `Size: ~${(asset.sizeBytes / 1024).toFixed(1)} KB`,
+      `Action: Safe to delete if not served directly via URL`,
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+
 // src/cli.ts
 function readPkgVersion() {
   try {
     if (typeof import.meta !== "undefined" && import.meta.url) {
-      const dir = path8.dirname(fileURLToPath(import.meta.url));
-      const pkgPath = path8.resolve(dir, "..", "package.json");
-      return JSON.parse(fs8.readFileSync(pkgPath, "utf-8")).version;
+      const dir = path9.dirname(fileURLToPath(import.meta.url));
+      const pkgPath = path9.resolve(dir, "..", "package.json");
+      return JSON.parse(fs9.readFileSync(pkgPath, "utf-8")).version;
     }
   } catch {
   }
   try {
     const dir = globalThis.__dirname ?? __dirname;
-    const pkgPath = path8.resolve(dir, "..", "package.json");
-    return JSON.parse(fs8.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path9.resolve(dir, "..", "package.json");
+    return JSON.parse(fs9.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return "0.0.0";
   }
 }
 var PKG_VERSION = readPkgVersion();
-var ALL_MODULES = ["dead-code", "dupes", "circular", "deps"];
+var ALL_MODULES = ["dead-code", "dupes", "circular", "deps", "assets"];
 var program = new Command();
 program.name("prunify").description("npm run clean. ship with confidence.").version(PKG_VERSION, "-v, --version").option("--dir <path>", "Root directory to analyze", process.cwd()).option("--entry <path>", "Override entry point").option("--only <modules>", "Comma-separated: dead-code,dupes,circular,deps,health").option(
   "--ignore <pattern>",
@@ -996,29 +1293,29 @@ program.name("prunify").description("npm run clean. ship with confidence.").vers
 ).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);
 program.parse();
 async function main(opts) {
-  const rootDir = path8.resolve(opts.dir);
-  if (!fs8.existsSync(path8.join(rootDir, "package.json"))) {
-    console.error(chalk6.red(`\u2717  No package.json found in ${rootDir}`));
-    console.error(chalk6.dim("   Use --dir <path> to point to your project root."));
+  const rootDir = path9.resolve(opts.dir);
+  if (!fs9.existsSync(path9.join(rootDir, "package.json"))) {
+    console.error(chalk7.red(`\u2717  No package.json found in ${rootDir}`));
+    console.error(chalk7.dim("   Use --dir <path> to point to your project root."));
     process.exit(1);
   }
   const modules = resolveModules(opts.only);
   console.log();
-  console.log(chalk6.bold.cyan("\u{1F9F9} prunify \u2014 npm run clean. ship with confidence."));
+  console.log(chalk7.bold.cyan("\u{1F9F9} prunify \u2014 npm run clean. ship with confidence."));
   console.log();
-  const parseSpinner = createSpinner(chalk6.cyan("Parsing codebase\u2026"));
+  const parseSpinner = createSpinner(chalk7.cyan("Parsing codebase\u2026"));
   const files = discoverFiles(rootDir, opts.ignore);
-  parseSpinner.succeed(chalk6.green(`Parsed codebase \u2014 ${files.length} file(s) found`));
-  const graphSpinner = createSpinner(chalk6.cyan("Building import graph\u2026"));
+  parseSpinner.succeed(chalk7.green(`Parsed codebase \u2014 ${files.length} file(s) found`));
+  const graphSpinner = createSpinner(chalk7.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(chalk6.green(`Import graph built \u2014 ${edgeCount} edge(s)`));
+  graphSpinner.succeed(chalk7.green(`Import graph built \u2014 ${edgeCount} edge(s)`));
   const packageJson = loadPackageJson2(rootDir);
-  const entryPoints = opts.entry ? [path8.resolve(opts.entry)] : findEntryPoints(rootDir, packageJson);
+  const entryPoints = opts.entry ? [path9.resolve(opts.entry)] : findEntryPoints(rootDir, packageJson);
   const reportsDir = ensureReportsDir(rootDir, opts.out);
   appendToGitignore(rootDir);
   console.log();
@@ -1026,90 +1323,120 @@ async function main(opts) {
   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")) {
-    const spinner = createSpinner(chalk6.cyan("Analysing dead code\u2026"));
+    const spinner = createSpinner(chalk7.cyan("Analysing dead code\u2026"));
     const result = runDeadCodeModule(project, graph, entryPoints, rootDir);
-    deadFileCount = result.deadFiles.length + result.deadExports.length;
-    deadFilePaths.push(...result.deadFiles);
-    spinner.succeed(chalk6.green(`Dead code analysis complete \u2014 ${deadFileCount} item(s) found`));
+    deadFileCount = result.safeToDelete.length + result.transitivelyDead.length + result.deadExports.length;
+    deadFilePaths.push(...result.safeToDelete, ...result.transitivelyDead);
+    spinner.succeed(
+      chalk7.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";
       writeReport(reportsDir, deadReportFile, result.report);
     }
   }
   if (modules.includes("dupes")) {
-    const outputPath = path8.join(reportsDir, "dupes.md");
+    const outputPath = path9.join(reportsDir, "dupes.md");
     const dupes = await runDupeFinder(rootDir, { output: outputPath });
     dupeCount = dupes.length;
     if (dupeCount > 0) dupesReportFile = "dupes.md";
   }
   if (modules.includes("circular")) {
-    const spinner = createSpinner(chalk6.cyan("Analysing circular imports\u2026"));
+    const spinner = createSpinner(chalk7.cyan("Analysing circular imports\u2026"));
     const cycles = detectCycles(graph);
     circularCount = cycles.length;
-    spinner.succeed(chalk6.green(`Circular import analysis complete \u2014 ${circularCount} cycle(s) found`));
+    spinner.succeed(chalk7.green(`Circular import analysis complete \u2014 ${circularCount} cycle(s) found`));
     if (circularCount > 0) {
       circularReportFile = "circular.txt";
-      const cycleText = cycles.map((c, i) => `Cycle ${i + 1}: ${c.join(" \u2192 ")}`).join("\n");
-      writeReport(reportsDir, circularReportFile, cycleText);
+      const rel = (p) => path9.relative(rootDir, p).replaceAll("\\", "/");
+      const cycleLines = [
+        "========================================",
+        "  CIRCULAR DEPENDENCIES",
+        `  Cycles found: ${cycles.length}`,
+        "========================================",
+        ""
+      ];
+      for (let i = 0; i < cycles.length; i++) {
+        const cycle = cycles[i];
+        cycleLines.push(`Cycle ${i + 1} (${cycle.length} files):`);
+        for (let j = 0; j < cycle.length; j++) {
+          const arrow = j < cycle.length - 1 ? "  \u2192 " : "  \u2192 ";
+          cycleLines.push(`  ${rel(cycle[j])}`);
+        }
+        cycleLines.push(`  \u21BB ${rel(cycle[0])}  (back to start)`);
+        cycleLines.push("");
+      }
+      writeReport(reportsDir, circularReportFile, cycleLines.join("\n"));
     }
   }
   if (modules.includes("deps")) {
-    const outputPath = path8.join(reportsDir, "deps.md");
+    const outputPath = path9.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 = path9.join(reportsDir, "assets.md");
+    const unusedAssets = await runAssetCheck(rootDir, { output: outputPath });
+    unusedAssetCount = unusedAssets.length;
+    if (unusedAssetCount > 0) assetsReportFile = "assets.md";
+  }
   if (modules.includes("health")) {
-    const outputPath = path8.join(reportsDir, "health-report.md");
+    const outputPath = path9.join(reportsDir, "health-report.md");
     await runHealthReport(rootDir, { output: outputPath });
   }
   if (opts.html) {
-    const htmlPath = path8.join(reportsDir, "code_health.html");
+    const htmlPath = path9.join(reportsDir, "code_health.html");
     writeHtmlReport(htmlPath, rootDir, deadFilePaths, circularCount, dupeCount, unusedPkgCount);
-    console.log(chalk6.cyan(`  HTML report written to ${htmlPath}`));
+    console.log(chalk7.cyan(`  HTML report written to ${htmlPath}`));
   }
   console.log();
-  console.log(chalk6.bold("Summary"));
+  console.log(chalk7.bold("Summary"));
   console.log();
-  const table = new Table5({
-    head: [chalk6.bold("Check"), chalk6.bold("Found"), chalk6.bold("Output File")],
+  const table = new Table6({
+    head: [chalk7.bold("Check"), chalk7.bold("Found"), chalk7.bold("Output File")],
     style: { head: [], border: [] }
   });
-  const fmt = (n) => n > 0 ? chalk6.yellow(String(n)) : chalk6.green("0");
+  const fmt = (n) => n > 0 ? chalk7.yellow(String(n)) : chalk7.green("0");
   table.push(
-    ["Dead Files / Exports", fmt(deadFileCount), deadReportFile || "\u2014"],
+    ["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"],
-    ["Circular Deps", fmt(circularCount), circularReportFile || "\u2014"]
+    ["Unused Assets", fmt(unusedAssetCount), assetsReportFile || "\u2014"]
   );
   console.log(table.toString());
   console.log();
   if (opts.delete && deadFilePaths.length > 0) {
-    console.log(chalk6.yellow(`Dead files (${deadFilePaths.length}):`));
+    console.log(chalk7.yellow(`Dead files (${deadFilePaths.length}):`));
     for (const f of deadFilePaths) {
-      console.log(chalk6.dim(`  ${path8.relative(rootDir, f)}`));
+      console.log(chalk7.dim(`  ${path9.relative(rootDir, f)}`));
     }
     console.log();
     if (!opts.ci) {
       const confirmed = await confirmPrompt("Delete these files? (y/N) ");
       if (confirmed) {
         for (const f of deadFilePaths) {
-          fs8.rmSync(f, { force: true });
+          fs9.rmSync(f, { force: true });
         }
-        console.log(chalk6.green(`  Deleted ${deadFilePaths.length} file(s).`));
+        console.log(chalk7.green(`  Deleted ${deadFilePaths.length} file(s).`));
       } else {
-        console.log(chalk6.dim("  Skipped."));
+        console.log(chalk7.dim("  Skipped."));
       }
     }
   }
   if (opts.ci) {
-    const hasIssues = deadFileCount > 0 || dupeCount > 0 || unusedPkgCount > 0 || circularCount > 0;
+    const hasIssues = deadFileCount > 0 || dupeCount > 0 || unusedPkgCount > 0 || circularCount > 0 || unusedAssetCount > 0;
     if (hasIssues) process.exit(1);
   }
 }
@@ -1120,7 +1447,7 @@ function resolveModules(only) {
 }
 function loadPackageJson2(dir) {
   try {
-    return JSON.parse(fs8.readFileSync(path8.join(dir, "package.json"), "utf-8"));
+    return JSON.parse(fs9.readFileSync(path9.join(dir, "package.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -1141,7 +1468,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>${path8.relative(rootDir, f)}</li>`).join("")}</ul>` : "<p>None</p>";
+  const deadList = deadFiles.length > 0 ? `<ul>${deadFiles.map((f) => `<li>${path9.relative(rootDir, f)}</li>`).join("")}</ul>` : "<p>None</p>";
   const html = `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -1168,7 +1495,7 @@ ${rows}
   ${deadList}
 </body>
 </html>`;
-  fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
-  fs8.writeFileSync(outputPath, html, "utf-8");
+  fs9.mkdirSync(path9.dirname(outputPath), { recursive: true });
+  fs9.writeFileSync(outputPath, html, "utf-8");
 }
 //# sourceMappingURL=cli.js.map