prunify 0.1.0

package/dist/cli.js

@@ -0,0 +1,1174 @@
+#!/usr/bin/env node
+
+// 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 { fileURLToPath } from "url";
+import readline from "readline";
+
+// src/core/parser.ts
+import fs2 from "fs";
+import path2 from "path";
+import { Project, Node, SyntaxKind } from "ts-morph";
+
+// src/utils/file.ts
+import fs from "fs";
+import path from "path";
+import { minimatch } from "minimatch";
+function glob(dir, patterns, ignore = []) {
+  const results = [];
+  collect(dir, dir, patterns, ignore, results);
+  return results;
+}
+function collect(base, current, patterns, ignore, results) {
+  let entries;
+  try {
+    entries = fs.readdirSync(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path.join(current, entry.name);
+    const relativePath = path.relative(base, fullPath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const isIgnored = ignore.some((pattern) => minimatch(relativePath, pattern));
+      if (!isIgnored) collect(base, fullPath, patterns, ignore, results);
+    } else if (entry.isFile()) {
+      const isIgnored = ignore.some((pattern) => minimatch(relativePath, pattern));
+      if (!isIgnored) {
+        const matches = patterns.some((pattern) => minimatch(relativePath, pattern));
+        if (matches) results.push(fullPath);
+      }
+    }
+  }
+}
+
+// src/core/parser.ts
+var DEFAULT_IGNORE = [
+  "node_modules",
+  "node_modules/**",
+  "dist",
+  "dist/**",
+  ".next",
+  ".next/**",
+  "coverage",
+  "coverage/**",
+  "**/*.test.ts",
+  "**/*.spec.ts",
+  "**/*.stories.tsx",
+  "**/*.d.ts"
+];
+var SOURCE_PATTERNS = ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"];
+var RESOLVE_EXTENSIONS = [
+  "",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx"
+];
+var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+function discoverFiles(rootDir, ignore = []) {
+  return glob(rootDir, SOURCE_PATTERNS, [...DEFAULT_IGNORE, ...ignore]);
+}
+function buildProject(files, tsconfigPath) {
+  const resolved = tsconfigPath ?? (files.length > 0 ? findTsconfig(files[0]) : void 0);
+  const project = resolved ? new Project({ tsConfigFilePath: resolved, skipAddingFilesFromTsConfig: true }) : new Project({
+    compilerOptions: {
+      allowJs: true,
+      resolveJsonModule: true
+    }
+  });
+  project.addSourceFilesAtPaths(files);
+  return project;
+}
+function getImportsForFile(sourceFile) {
+  const result = /* @__PURE__ */ new Set();
+  const fileDir = path2.dirname(sourceFile.getFilePath());
+  const project = sourceFile.getProject();
+  const compilerOptions = project.getCompilerOptions();
+  const pathAliases = compilerOptions.paths ?? {};
+  const baseUrl = compilerOptions.baseUrl;
+  function addResolved(sf) {
+    if (!sf) return;
+    const p = path2.normalize(sf.getFilePath());
+    if (!p.includes(`${path2.sep}node_modules${path2.sep}`) && !p.includes("/node_modules/") && path2.normalize(sourceFile.getFilePath()) !== p) {
+      result.add(p);
+    }
+  }
+  function resolveAndAdd(specifier) {
+    if (!specifier) return;
+    const isRelative = specifier.startsWith("./") || specifier.startsWith("../");
+    if (isRelative) {
+      const p = resolveRelativePath(fileDir, specifier, project);
+      if (p) result.add(p);
+    } else if (!specifier.startsWith("node:")) {
+      const p = resolvePathAlias(specifier, pathAliases, baseUrl, project);
+      if (p) result.add(p);
+    }
+  }
+  for (const decl of sourceFile.getImportDeclarations()) {
+    const sf = decl.getModuleSpecifierSourceFile();
+    sf ? addResolved(sf) : resolveAndAdd(decl.getModuleSpecifierValue());
+  }
+  for (const decl of sourceFile.getExportDeclarations()) {
+    const specifier = decl.getModuleSpecifierValue();
+    if (!specifier) continue;
+    const sf = decl.getModuleSpecifierSourceFile();
+    sf ? addResolved(sf) : resolveAndAdd(specifier);
+  }
+  for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+    if (call.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+    const args = call.getArguments();
+    if (args.length > 0 && Node.isStringLiteral(args[0])) {
+      resolveAndAdd(args[0].getLiteralValue());
+    }
+  }
+  return [...result];
+}
+function resolveRelativePath(fromDir, specifier, project) {
+  const base = path2.resolve(fromDir, specifier);
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const sf = project.getSourceFile(base + ext);
+    if (sf) return path2.normalize(sf.getFilePath());
+  }
+  for (const index of INDEX_FILES) {
+    const sf = project.getSourceFile(path2.join(base, index));
+    if (sf) return path2.normalize(sf.getFilePath());
+  }
+  return null;
+}
+function resolvePathAlias(specifier, pathAliases, baseUrl, project) {
+  for (const [alias, targets] of Object.entries(pathAliases)) {
+    const match = matchAlias(alias, specifier);
+    if (!match) continue;
+    const capture = match[1] ?? "";
+    for (const target of targets) {
+      const resolved = target.replaceAll("*", capture);
+      const absolute = baseUrl ? path2.resolve(baseUrl, resolved) : path2.resolve(resolved);
+      const hit = tryResolveAbsolute(absolute, project);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+function matchAlias(alias, specifier) {
+  const escaped = alias.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const pattern = escaped.replaceAll("*", "(.*)");
+  return new RegExp(`^${pattern}$`).exec(specifier);
+}
+function tryResolveAbsolute(absolute, project) {
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const sf = project.getSourceFile(absolute + ext);
+    if (sf) return path2.normalize(sf.getFilePath());
+  }
+  for (const index of INDEX_FILES) {
+    const sf = project.getSourceFile(path2.join(absolute, index));
+    if (sf) return path2.normalize(sf.getFilePath());
+  }
+  return null;
+}
+function findTsconfig(fromFile) {
+  let dir = path2.dirname(fromFile);
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    const candidate = path2.join(dir, "tsconfig.json");
+    if (fs2.existsSync(candidate)) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+
+// src/core/graph.ts
+import fs3 from "fs";
+import path3 from "path";
+function buildGraph(files, getImports) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    graph.set(file, /* @__PURE__ */ new Set());
+  }
+  for (const file of files) {
+    for (const imported of getImports(file)) {
+      graph.get(file)?.add(imported);
+      if (!graph.has(imported)) graph.set(imported, /* @__PURE__ */ new Set());
+    }
+  }
+  return graph;
+}
+function findEntryPoints(rootDir, packageJson) {
+  const entries = [
+    ...resolveNextJsEntries(rootDir),
+    ...resolvePkgFieldEntries(rootDir, packageJson)
+  ];
+  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 acc = { seenKeys, cycles };
+  for (const start of graph.keys()) {
+    if (!visited.has(start)) {
+      dfsForCycles(start, graph, visited, inStack, path9, acc);
+    }
+  }
+  return cycles;
+}
+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"]) {
+    const dirPath = path3.join(rootDir, dir);
+    if (fs3.existsSync(dirPath)) entries.push(...collectSourceFiles(dirPath));
+  }
+  return entries;
+}
+function resolvePkgFieldEntries(rootDir, packageJson) {
+  const entries = [];
+  for (const field of ["main", "module"]) {
+    const value = packageJson?.[field];
+    if (typeof value !== "string") continue;
+    const abs = path3.resolve(rootDir, value);
+    if (fs3.existsSync(abs)) entries.push(abs);
+  }
+  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 mkFrame(node, graph) {
+  return { node, neighbors: (graph.get(node) ?? /* @__PURE__ */ new Set()).values(), entered: false };
+}
+function dfsForCycles(start, graph, visited, inStack, path9, acc) {
+  const stack = [mkFrame(start, graph)];
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (!frame) break;
+    if (!frame.entered) {
+      if (visited.has(frame.node)) {
+        stack.pop();
+        continue;
+      }
+      frame.entered = true;
+      inStack.add(frame.node);
+      path9.push(frame.node);
+    }
+    const { done, value: neighbor } = frame.neighbors.next();
+    if (done) {
+      stack.pop();
+      path9.pop();
+      inStack.delete(frame.node);
+      visited.add(frame.node);
+    } else {
+      handleCycleNeighbor(neighbor, stack, path9, inStack, visited, acc, graph);
+    }
+  }
+}
+function handleCycleNeighbor(neighbor, stack, path9, inStack, visited, acc, graph) {
+  if (inStack.has(neighbor)) {
+    recordCycle(neighbor, path9, acc);
+  } else if (!visited.has(neighbor)) {
+    stack.push(mkFrame(neighbor, graph));
+  }
+}
+function recordCycle(cycleStart, path9, acc) {
+  const idx = path9.indexOf(cycleStart);
+  if (idx === -1) return;
+  const cycle = normalizeCycle(path9.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) {
+    if (!rev.has(file)) rev.set(file, /* @__PURE__ */ new Set());
+  }
+  for (const [file, imports] of graph) {
+    for (const imp of imports) {
+      if (!rev.has(imp)) rev.set(imp, /* @__PURE__ */ new Set());
+      rev.get(imp)?.add(file);
+    }
+  }
+  return rev;
+}
+function normalizeCycle(cycle) {
+  if (cycle.length === 0) return cycle;
+  const minIdx = cycle.reduce(
+    (best, cur, i) => cur < cycle[best] ? i : best,
+    0
+  );
+  return [...cycle.slice(minIdx), ...cycle.slice(0, minIdx)];
+}
+function collectSourceFiles(dir) {
+  const results = [];
+  const SOURCE_RE = /\.(tsx?|jsx?)$/;
+  function walk(current) {
+    let entries;
+    try {
+      entries = fs3.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile() && SOURCE_RE.test(entry.name)) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+// src/modules/dead-code.ts
+import ora2 from "ora";
+import chalk from "chalk";
+import Table from "cli-table3";
+import fs5 from "fs";
+import path5 from "path";
+import { Node as Node2 } from "ts-morph";
+
+// src/core/reporter.ts
+import fs4 from "fs";
+import path4 from "path";
+import ora from "ora";
+function createSpinner(text) {
+  return ora(text).start();
+}
+var REPORTS_DIR_NAME = "prunify-reports";
+function ensureReportsDir(rootDir, outDir) {
+  const base = outDir ? path4.resolve(outDir) : path4.resolve(rootDir);
+  const reportsDir = path4.join(base, REPORTS_DIR_NAME);
+  if (!fs4.existsSync(reportsDir)) {
+    fs4.mkdirSync(reportsDir, { recursive: true });
+  }
+  return reportsDir;
+}
+function writeReport(reportsDir, filename, content) {
+  ensureDir(reportsDir);
+  const filePath = path4.join(reportsDir, filename);
+  fs4.writeFileSync(filePath, content, "utf-8");
+  console.log(`  Report saved \u2192 ${filePath}`);
+}
+function appendToGitignore(rootDir) {
+  const gitignorePath = path4.join(rootDir, ".gitignore");
+  const entry = `${REPORTS_DIR_NAME}/`;
+  if (fs4.existsSync(gitignorePath)) {
+    const contents = fs4.readFileSync(gitignorePath, "utf-8");
+    if (contents.split("\n").some((line) => line.trim() === entry)) return;
+    fs4.appendFileSync(gitignorePath, `
+${entry}
+`, "utf-8");
+  } else {
+    fs4.writeFileSync(gitignorePath, `${entry}
+`, "utf-8");
+  }
+}
+function writeMarkdown(report, outputPath) {
+  const lines = [
+    `# ${report.title}`,
+    "",
+    `> ${report.summary}`,
+    "",
+    `_Generated: ${report.generatedAt.toISOString()}_`,
+    ""
+  ];
+  for (const section of report.sections) {
+    lines.push(`## ${section.title}`, "");
+    if (section.rows.length === 0) {
+      lines.push("_Nothing found._", "");
+      continue;
+    }
+    if (section.headers && section.headers.length > 0) {
+      lines.push(`| ${section.headers.join(" | ")} |`);
+      lines.push(`| ${section.headers.map(() => "---").join(" | ")} |`);
+    }
+    for (const row of section.rows) {
+      lines.push(`| ${row.join(" | ")} |`);
+    }
+    lines.push("");
+  }
+  ensureDir(path4.dirname(outputPath));
+  fs4.writeFileSync(outputPath, lines.join("\n"), "utf-8");
+}
+function writeJson(data, outputPath) {
+  ensureDir(path4.dirname(outputPath));
+  fs4.writeFileSync(outputPath, JSON.stringify(data, null, 2), "utf-8");
+}
+function ensureDir(dir) {
+  if (dir && !fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/modules/dead-code.ts
+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 deadExports = findDeadExports(project, liveFiles);
+  const report = buildDeadCodeReport(deadFiles, chains, deadExports, rootDir);
+  return { deadFiles, liveFiles, chains, deadExports, report };
+}
+function findDeadExports(project, liveFiles) {
+  const importedNames = buildImportedNameMap(project, liveFiles);
+  const dead = [];
+  for (const filePath of liveFiles) {
+    collectFileDeadExports(filePath, project, importedNames, dead);
+  }
+  return dead;
+}
+function collectFileDeadExports(filePath, project, importedNames, dead) {
+  const sf = project.getSourceFile(filePath);
+  if (!sf) return;
+  const usedNames = importedNames.get(filePath) ?? /* @__PURE__ */ new Set();
+  if (usedNames.has("*")) return;
+  for (const [exportName, declarations] of sf.getExportedDeclarations()) {
+    if (usedNames.has(exportName)) continue;
+    const line = getExportLine(declarations[0]);
+    dead.push({ filePath, exportName, line });
+  }
+}
+function getExportLine(decl) {
+  if (!decl) return 0;
+  if (!Node2.isNode(decl)) return 0;
+  return decl.getStartLineNumber();
+}
+function getFileSize(filePath) {
+  try {
+    return fs5.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function buildDeadCodeReport(deadFiles, 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 totalKb = (totalBytes / 1024).toFixed(1);
+  const lines = [
+    "========================================",
+    "  DEAD CODE REPORT",
+    `  Dead files : ${deadFiles.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) {
+      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}`,
+        ""
+      );
+    }
+  }
+  if (deadExports.length > 0) {
+    lines.push("\u2500\u2500 DEAD EXPORTS \u2500\u2500", "");
+    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)`,
+        ""
+      );
+    }
+  }
+  return lines.join("\n");
+}
+async function runDeadCode(dir, opts) {
+  const spinner = ora2(chalk.cyan("Scanning for dead code\u2026")).start();
+  try {
+    const fileList = discoverFiles(dir, []);
+    const project = buildProject(fileList);
+    const graph = buildGraph(fileList, (f) => {
+      const sf = project.getSourceFile(f);
+      return sf ? getImportsForFile(sf) : [];
+    });
+    const packageJson = loadPackageJson(dir);
+    const entries = findEntryPoints(dir, packageJson);
+    const result = runDeadCodeModule(project, graph, entries, dir);
+    const dead = [
+      ...result.deadFiles.map((f) => ({ file: f, exportName: "(entire file)" })),
+      ...result.deadExports.map((e) => ({ file: e.filePath, exportName: e.exportName }))
+    ];
+    spinner.succeed(chalk.green(`Dead code scan complete \u2014 ${dead.length} item(s) found`));
+    if (dead.length === 0) {
+      console.log(chalk.green("  No dead code detected."));
+      return dead;
+    }
+    printDeadTable(dead);
+    writeDeadOutput(result, opts);
+    return dead;
+  } catch (err) {
+    spinner.fail(chalk.red("Dead code scan failed"));
+    throw err;
+  }
+}
+function buildImportedNameMap(project, liveFiles) {
+  const importedNames = /* @__PURE__ */ new Map();
+  const touch = (file, name) => {
+    if (!importedNames.has(file)) importedNames.set(file, /* @__PURE__ */ new Set());
+    importedNames.get(file).add(name);
+  };
+  for (const filePath of liveFiles) {
+    const sf = project.getSourceFile(filePath);
+    if (!sf) continue;
+    processImports(sf, touch);
+    processReExports(sf, touch);
+  }
+  return importedNames;
+}
+function processImports(sf, touch) {
+  for (const decl of sf.getImportDeclarations()) {
+    const resolved = decl.getModuleSpecifierSourceFile();
+    if (!resolved) continue;
+    const target = resolved.getFilePath();
+    if (decl.getNamespaceImport()) {
+      touch(target, "*");
+      continue;
+    }
+    const defaultImport = decl.getDefaultImport();
+    if (defaultImport) touch(target, "default");
+    for (const named of decl.getNamedImports()) {
+      touch(target, named.getAliasNode()?.getText() ?? named.getName());
+    }
+  }
+}
+function processReExports(sf, touch) {
+  for (const decl of sf.getExportDeclarations()) {
+    const resolved = decl.getModuleSpecifierSourceFile();
+    if (!resolved) continue;
+    const target = resolved.getFilePath();
+    if (decl.isNamespaceExport()) {
+      touch(target, "*");
+      continue;
+    }
+    for (const named of decl.getNamedExports()) {
+      touch(target, named.getName());
+    }
+  }
+}
+function loadPackageJson(dir) {
+  const pkgPath = path5.join(dir, "package.json");
+  if (!fs5.existsSync(pkgPath)) return null;
+  return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+}
+function printDeadTable(dead) {
+  const table = new Table({ head: ["File", "Export"] });
+  for (const row of dead) {
+    table.push([row.file, row.exportName]);
+  }
+  console.log(table.toString());
+}
+function writeDeadOutput(result, opts) {
+  if (!opts.output) return;
+  if (opts.json) {
+    writeJson(
+      { deadFiles: result.deadFiles, deadExports: result.deadExports },
+      opts.output
+    );
+    console.log(chalk.cyan(`  JSON written to ${opts.output}`));
+    return;
+  }
+  writeMarkdown(
+    {
+      title: "Dead Code Report",
+      summary: `${result.deadFiles.length} dead file(s), ${result.deadExports.length} dead export(s)`,
+      sections: [
+        {
+          title: "Dead Files",
+          headers: ["File", "Chain"],
+          rows: result.deadFiles.map((f) => [
+            f,
+            (result.chains.get(f) ?? []).join(" \u2192 ") || "\u2014"
+          ])
+        },
+        {
+          title: "Dead Exports",
+          headers: ["File", "Export", "Line"],
+          rows: result.deadExports.map((e) => [e.filePath, e.exportName, String(e.line)])
+        }
+      ],
+      generatedAt: /* @__PURE__ */ new Date()
+    },
+    opts.output
+  );
+  console.log(chalk.cyan(`  Report written to ${opts.output}`));
+}
+
+// src/modules/dupe-finder.ts
+import ora3 from "ora";
+import chalk2 from "chalk";
+import Table2 from "cli-table3";
+import fs6 from "fs";
+import { SyntaxKind as SyntaxKind3, VariableDeclarationKind } from "ts-morph";
+
+// src/utils/ast.ts
+import crypto from "crypto";
+import {
+  Node as Node3,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+
+// src/modules/dupe-finder.ts
+async function runDupeFinder(dir, opts) {
+  const minLines = parseInt(opts.minLines ?? "5", 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 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");
+        if (!blockMap.has(block)) blockMap.set(block, []);
+        blockMap.get(block).push({ file: filePath, startLine: i + 1 });
+      }
+    }
+    const dupes = [];
+    for (const [block, occurrences] of blockMap) {
+      if (occurrences.length > 1) {
+        dupes.push({
+          hash: hashString(block),
+          lines: minLines,
+          occurrences
+        });
+      }
+    }
+    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."));
+      return dupes;
+    }
+    const table = new Table2({ head: ["Hash", "Lines", "Count", "First Occurrence"] });
+    for (const d of dupes) {
+      table.push([
+        chalk2.gray(d.hash.slice(0, 8)),
+        String(d.lines),
+        chalk2.yellow(String(d.occurrences.length)),
+        `${d.occurrences[0].file}:${d.occurrences[0].startLine}`
+      ]);
+    }
+    console.log(table.toString());
+    if (opts.output) {
+      const rows = dupes.flatMap(
+        (d) => d.occurrences.map((o) => [d.hash.slice(0, 8), String(d.lines), o.file, String(o.startLine)])
+      );
+      writeMarkdown(
+        {
+          title: "Duplicate Code Report",
+          summary: `${dupes.length} duplicate block(s) found (min lines: ${minLines})`,
+          sections: [{ title: "Duplicates", headers: ["Hash", "Lines", "File", "Start Line"], rows }],
+          generatedAt: /* @__PURE__ */ new Date()
+        },
+        opts.output
+      );
+      console.log(chalk2.cyan(`  Report written to ${opts.output}`));
+    }
+    return dupes;
+  } catch (err) {
+    spinner.fail(chalk2.red("Duplicate scan failed"));
+    throw err;
+  }
+}
+function hashString(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/modules/dep-check.ts
+import ora4 from "ora";
+import chalk3 from "chalk";
+import Table3 from "cli-table3";
+import fs7 from "fs";
+import path6 from "path";
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+async function runDepCheck(opts) {
+  const spinner = ora4(chalk3.cyan("Auditing dependencies\u2026")).start();
+  try {
+    const pkgPath = path6.join(opts.cwd, "package.json");
+    if (!fs7.existsSync(pkgPath)) {
+      spinner.fail(chalk3.red(`No package.json found at ${opts.cwd}`));
+      return [];
+    }
+    const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    const declared = /* @__PURE__ */ new Set([
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {})
+    ]);
+    const srcDir = path6.join(opts.cwd, "src");
+    const files = glob(srcDir, ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx"], ["node_modules", "dist"]);
+    const usedPackages = /* @__PURE__ */ new Set();
+    for (const filePath of files) {
+      const content = fs7.readFileSync(filePath, "utf-8");
+      const importRegex = /from\s+['"]([^'"./][^'"]*)['"]/g;
+      let match;
+      while ((match = importRegex.exec(content)) !== null) {
+        const specifier = match[1];
+        const pkgName = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+        usedPackages.add(pkgName);
+      }
+    }
+    const issues = [];
+    for (const dep of declared) {
+      if (!usedPackages.has(dep)) {
+        issues.push({ name: dep, type: "unused" });
+      }
+    }
+    for (const pkg2 of usedPackages) {
+      if (!declared.has(pkg2) && !isBuiltin(pkg2)) {
+        issues.push({ name: pkg2, type: "missing" });
+      }
+    }
+    spinner.succeed(chalk3.green(`Dependency audit complete \u2014 ${issues.length} issue(s) found`));
+    if (issues.length === 0) {
+      console.log(chalk3.green("  All dependencies look healthy."));
+      return issues;
+    }
+    const table = new Table3({ head: ["Package", "Issue"] });
+    for (const issue of issues) {
+      const label = issue.type === "unused" ? chalk3.yellow("unused") : issue.type === "missing" ? chalk3.red("missing from package.json") : chalk3.magenta("unlisted dev dep");
+      table.push([chalk3.gray(issue.name), label]);
+    }
+    console.log(table.toString());
+    if (opts.output) {
+      writeMarkdown(
+        {
+          title: "Dependency Audit Report",
+          summary: `${issues.length} dependency issue(s) found`,
+          sections: [
+            {
+              title: "Issues",
+              headers: ["Package", "Type"],
+              rows: issues.map((i) => [i.name, i.type])
+            }
+          ],
+          generatedAt: /* @__PURE__ */ new Date()
+        },
+        opts.output
+      );
+      console.log(chalk3.cyan(`  Report written to ${opts.output}`));
+    }
+    return issues;
+  } catch (err) {
+    spinner.fail(chalk3.red("Dependency audit failed"));
+    throw err;
+  }
+}
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "node:fs",
+  "node:path",
+  "node:os",
+  "node:url",
+  "node:crypto",
+  "node:util",
+  "node:stream",
+  "node:events",
+  "node:child_process",
+  "node:process",
+  "fs",
+  "path",
+  "os",
+  "url",
+  "crypto",
+  "util",
+  "stream",
+  "events",
+  "child_process"
+]);
+function isBuiltin(name) {
+  return NODE_BUILTINS.has(name) || name.startsWith("node:");
+}
+
+// src/modules/health-report.ts
+import chalk5 from "chalk";
+import path7 from "path";
+
+// src/modules/circular.ts
+import ora5 from "ora";
+import chalk4 from "chalk";
+import Table4 from "cli-table3";
+async function runCircular(dir, opts) {
+  const spinner = ora5(chalk4.cyan("Scanning for circular imports\u2026")).start();
+  try {
+    const fileList = discoverFiles(dir, []);
+    const project = buildProject(fileList);
+    const graph = buildGraph(fileList, (f) => {
+      const sf = project.getSourceFile(f);
+      return sf ? getImportsForFile(sf) : [];
+    });
+    const cycles = detectCycles(graph);
+    spinner.succeed(
+      chalk4.green(`Circular import scan complete \u2014 ${cycles.length} cycle(s) found`)
+    );
+    if (cycles.length === 0) {
+      console.log(chalk4.green("  No circular imports detected."));
+      return cycles;
+    }
+    const table = new Table4({ head: ["Cycle #", "Files involved"] });
+    cycles.forEach((cycle, i) => {
+      table.push([chalk4.yellow(String(i + 1)), cycle.map((f) => chalk4.gray(f)).join("\n  \u2192 ")]);
+    });
+    console.log(table.toString());
+    if (opts.output) {
+      writeMarkdown(
+        {
+          title: "Circular Imports Report",
+          summary: `${cycles.length} circular import chain(s) found`,
+          sections: [
+            {
+              title: "Circular Chains",
+              headers: ["Cycle #", "Files"],
+              rows: cycles.map((cycle, i) => [String(i + 1), cycle.join(" \u2192 ")])
+            }
+          ],
+          generatedAt: /* @__PURE__ */ new Date()
+        },
+        opts.output
+      );
+      console.log(chalk4.cyan(`  Report written to ${opts.output}`));
+    }
+    return cycles;
+  } catch (err) {
+    spinner.fail(chalk4.red("Circular import scan failed"));
+    throw err;
+  }
+}
+
+// src/modules/health-report.ts
+async function runHealthReport(dir, opts) {
+  console.log(chalk5.bold.cyan("\n  prunify \u2014 Codebase Health Report\n"));
+  const [deadExports, dupes, cycles, depIssues] = await Promise.all([
+    runDeadCode(dir, {}).catch(() => []),
+    runDupeFinder(dir, {}).catch(() => []),
+    runCircular(dir, {}).catch(() => []),
+    runDepCheck({ cwd: path7.resolve(dir, ".."), output: void 0 }).catch(() => [])
+  ]);
+  const sections = [
+    {
+      title: "\u{1F6A8} Dead Exports",
+      headers: ["File", "Export"],
+      rows: deadExports.map((d) => [d.file, d.exportName])
+    },
+    {
+      title: "\u{1F501} Duplicate Blocks",
+      headers: ["Hash", "Lines", "Occurrences"],
+      rows: dupes.map((d) => [d.hash.slice(0, 8), String(d.lines), String(d.occurrences.length)])
+    },
+    {
+      title: "\u267B\uFE0F Circular Imports",
+      headers: ["Cycle #", "Chain"],
+      rows: cycles.map((cycle, i) => [String(i + 1), cycle.join(" \u2192 ")])
+    },
+    {
+      title: "\u{1F4E6} Dependency Issues",
+      headers: ["Package", "Issue"],
+      rows: depIssues.map((i) => [i.name, i.type])
+    }
+  ];
+  const totalIssues = deadExports.length + dupes.length + cycles.length + depIssues.length;
+  const report = {
+    title: "Codebase Health Report",
+    summary: `Analysed: ${path7.resolve(dir)} | Total issues: ${totalIssues}`,
+    sections,
+    generatedAt: /* @__PURE__ */ new Date()
+  };
+  writeMarkdown(report, opts.output);
+  console.log(
+    chalk5.bold(`
+  Health report written to `) + chalk5.cyan(opts.output)
+  );
+  console.log(
+    chalk5.dim(`  Total issues found: `) + (totalIssues > 0 ? chalk5.red(String(totalIssues)) : chalk5.green("0"))
+  );
+}
+
+// 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;
+    }
+  } catch {
+  }
+  try {
+    const dir = globalThis.__dirname ?? __dirname;
+    const pkgPath = path8.resolve(dir, "..", "package.json");
+    return JSON.parse(fs8.readFileSync(pkgPath, "utf-8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var PKG_VERSION = readPkgVersion();
+var ALL_MODULES = ["dead-code", "dupes", "circular", "deps"];
+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>",
+  "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);
+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."));
+    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();
+  const parseSpinner = createSpinner(chalk6.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"));
+  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)`));
+  const packageJson = loadPackageJson2(rootDir);
+  const entryPoints = opts.entry ? [path8.resolve(opts.entry)] : findEntryPoints(rootDir, packageJson);
+  const reportsDir = ensureReportsDir(rootDir, opts.out);
+  appendToGitignore(rootDir);
+  console.log();
+  let deadFileCount = 0;
+  let dupeCount = 0;
+  let unusedPkgCount = 0;
+  let circularCount = 0;
+  let deadReportFile = "";
+  let dupesReportFile = "";
+  let depsReportFile = "";
+  let circularReportFile = "";
+  const deadFilePaths = [];
+  if (modules.includes("dead-code")) {
+    const spinner = createSpinner(chalk6.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`));
+    if (result.report) {
+      deadReportFile = "dead-code.txt";
+      writeReport(reportsDir, deadReportFile, result.report);
+    }
+  }
+  if (modules.includes("dupes")) {
+    const outputPath = path8.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 cycles = detectCycles(graph);
+    circularCount = cycles.length;
+    spinner.succeed(chalk6.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);
+    }
+  }
+  if (modules.includes("deps")) {
+    const outputPath = path8.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("health")) {
+    const outputPath = path8.join(reportsDir, "health-report.md");
+    await runHealthReport(rootDir, { output: outputPath });
+  }
+  if (opts.html) {
+    const htmlPath = path8.join(reportsDir, "code_health.html");
+    writeHtmlReport(htmlPath, rootDir, deadFilePaths, circularCount, dupeCount, unusedPkgCount);
+    console.log(chalk6.cyan(`  HTML report written to ${htmlPath}`));
+  }
+  console.log();
+  console.log(chalk6.bold("Summary"));
+  console.log();
+  const table = new Table5({
+    head: [chalk6.bold("Check"), chalk6.bold("Found"), chalk6.bold("Output File")],
+    style: { head: [], border: [] }
+  });
+  const fmt = (n) => n > 0 ? chalk6.yellow(String(n)) : chalk6.green("0");
+  table.push(
+    ["Dead Files / Exports", fmt(deadFileCount), deadReportFile || "\u2014"],
+    ["Duplicate Clusters", fmt(dupeCount), dupesReportFile || "\u2014"],
+    ["Unused Packages", fmt(unusedPkgCount), depsReportFile || "\u2014"],
+    ["Circular Deps", fmt(circularCount), circularReportFile || "\u2014"]
+  );
+  console.log(table.toString());
+  console.log();
+  if (opts.delete && deadFilePaths.length > 0) {
+    console.log(chalk6.yellow(`Dead files (${deadFilePaths.length}):`));
+    for (const f of deadFilePaths) {
+      console.log(chalk6.dim(`  ${path8.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 });
+        }
+        console.log(chalk6.green(`  Deleted ${deadFilePaths.length} file(s).`));
+      } else {
+        console.log(chalk6.dim("  Skipped."));
+      }
+    }
+  }
+  if (opts.ci) {
+    const hasIssues = deadFileCount > 0 || dupeCount > 0 || unusedPkgCount > 0 || circularCount > 0;
+    if (hasIssues) process.exit(1);
+  }
+}
+function resolveModules(only) {
+  if (!only) return ALL_MODULES;
+  const valid = /* @__PURE__ */ new Set([...ALL_MODULES, "health"]);
+  return only.split(",").map((s) => s.trim()).filter((m) => valid.has(m));
+}
+function loadPackageJson2(dir) {
+  try {
+    return JSON.parse(fs8.readFileSync(path8.join(dir, "package.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function confirmPrompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+function writeHtmlReport(outputPath, rootDir, deadFiles, circularCount, dupeCount, unusedPkgCount) {
+  const rows = [
+    ["Dead Files / Exports", String(deadFiles.length)],
+    ["Duplicate Clusters", String(dupeCount)],
+    ["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 html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>prunify \u2014 Code Health Report</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+    h1 { color: #0ea5e9; }
+    table { border-collapse: collapse; width: 100%; margin-bottom: 2rem; }
+    th, td { border: 1px solid #e2e8f0; padding: .5rem 1rem; text-align: left; }
+    th { background: #f8fafc; }
+    small { color: #94a3b8; }
+  </style>
+</head>
+<body>
+  <h1>\u{1F9F9} prunify \u2014 Code Health Report</h1>
+  <small>Generated ${(/* @__PURE__ */ new Date()).toISOString()}</small>
+  <h2>Summary</h2>
+  <table>
+    <tr><th>Check</th><th>Found</th></tr>
+${rows}
+  </table>
+  <h2>Dead Files</h2>
+  ${deadList}
+</body>
+</html>`;
+  fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+  fs8.writeFileSync(outputPath, html, "utf-8");
+}
+//# sourceMappingURL=cli.js.map