@kb-labs/quality-core 0.6.0

package/dist/dead-code/index.js

@@ -0,0 +1,837 @@
+import fs4 from 'fs';
+import path4 from 'path';
+import globby from 'globby';
+import { execSync } from 'child_process';
+
+// src/dead-code/scan-dead-files.ts
+var CONFIG_FILE_PATTERNS = [
+  "tsup.config.ts",
+  "tsup.config.mts",
+  "tsup.config.js",
+  "tsup.config.mjs",
+  "tsup.bin.config.ts",
+  "tsup.lib.config.ts",
+  "vitest.config.ts",
+  "vitest.config.mts",
+  "vitest.config.js",
+  "jest.config.ts",
+  "jest.config.js",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "vitest.setup.ts",
+  "vitest.setup.js"
+];
+async function collectEntryPoints(packageDir, packageJson) {
+  const entryFiles = /* @__PURE__ */ new Set();
+  const aliveByConvention = /* @__PURE__ */ new Set();
+  const warnings = [];
+  let failOpen = false;
+  collectPackageJsonEntries(packageDir, packageJson, entryFiles);
+  const tsupOk = await collectTsupEntries(packageDir, entryFiles, warnings);
+  if (!tsupOk) {
+    failOpen = true;
+  }
+  collectManifestHandlers(packageDir, entryFiles, warnings);
+  await collectDynamicImportTargets(packageDir, entryFiles);
+  await collectTestFiles(packageDir, aliveByConvention);
+  collectConfigFiles(packageDir, aliveByConvention);
+  if (entryFiles.size === 0) {
+    const defaultEntry = path4.join(packageDir, "src", "index.ts");
+    if (fs4.existsSync(defaultEntry)) {
+      entryFiles.add(defaultEntry);
+      warnings.push("No entry points found, using src/index.ts as default");
+    }
+  }
+  return { entryFiles, aliveByConvention, warnings, failOpen };
+}
+function distPathToSrcPath(distPath, packageDir) {
+  let normalized = distPath.replace(/^\.?\/?/, "");
+  if (normalized.startsWith("dist/") || normalized.startsWith("dist\\")) {
+    normalized = "src/" + normalized.slice(5);
+  }
+  normalized = normalized.replace(/\.d\.ts$/, ".ts").replace(/\.js$/, ".ts").replace(/\.mjs$/, ".ts").replace(/\.cjs$/, ".ts");
+  const absolute = path4.resolve(packageDir, normalized);
+  if (fs4.existsSync(absolute)) {
+    return absolute;
+  }
+  const indexPath = path4.join(absolute.replace(/\.ts$/, ""), "index.ts");
+  if (fs4.existsSync(indexPath)) {
+    return indexPath;
+  }
+  return null;
+}
+function collectPackageJsonEntries(packageDir, pkgJson, entryFiles, warnings) {
+  for (const field of ["main", "module", "types", "typings"]) {
+    const value = pkgJson[field];
+    if (typeof value === "string") {
+      const srcPath = distPathToSrcPath(value, packageDir);
+      if (srcPath) {
+        entryFiles.add(srcPath);
+      }
+    }
+  }
+  const bin = pkgJson["bin"];
+  if (typeof bin === "string") {
+    const srcPath = distPathToSrcPath(bin, packageDir);
+    if (srcPath) {
+      entryFiles.add(srcPath);
+    }
+  } else if (bin && typeof bin === "object") {
+    for (const value of Object.values(bin)) {
+      if (typeof value === "string") {
+        const srcPath = distPathToSrcPath(value, packageDir);
+        if (srcPath) {
+          entryFiles.add(srcPath);
+        }
+      }
+    }
+  }
+  const exports$1 = pkgJson["exports"];
+  if (exports$1 && typeof exports$1 === "object") {
+    collectExportsEntries(
+      packageDir,
+      exports$1,
+      entryFiles);
+  }
+}
+function collectExportsEntries(packageDir, exports$1, entryFiles, _warnings) {
+  for (const [key, value] of Object.entries(exports$1)) {
+    if (key.includes("*")) {
+      continue;
+    }
+    const importPath = extractImportPath(value);
+    if (importPath) {
+      const srcPath = distPathToSrcPath(importPath, packageDir);
+      if (srcPath) {
+        entryFiles.add(srcPath);
+      }
+    }
+  }
+}
+function extractImportPath(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    for (const key of ["import", "default", "require"]) {
+      if (typeof obj[key] === "string") {
+        return obj[key];
+      }
+    }
+  }
+  return null;
+}
+async function collectTsupEntries(packageDir, entryFiles, warnings) {
+  const tsupConfigs = [
+    "tsup.config.ts",
+    "tsup.config.mts",
+    "tsup.config.js",
+    "tsup.config.mjs",
+    "tsup.bin.config.ts",
+    "tsup.lib.config.ts"
+  ];
+  let foundAny = false;
+  for (const configName of tsupConfigs) {
+    const configPath = path4.join(packageDir, configName);
+    if (!fs4.existsSync(configPath)) {
+      continue;
+    }
+    foundAny = true;
+    try {
+      const content = fs4.readFileSync(configPath, "utf-8");
+      const entries = parseTsupEntries(content);
+      for (const entry of entries) {
+        if (entry.includes("*") || entry.includes("{")) {
+          const expanded = await globby(entry, {
+            cwd: packageDir,
+            absolute: true
+          });
+          for (const file of expanded) {
+            entryFiles.add(file);
+          }
+        } else {
+          const absolute = path4.resolve(packageDir, entry);
+          if (fs4.existsSync(absolute)) {
+            entryFiles.add(absolute);
+          }
+        }
+      }
+    } catch {
+      warnings.push(`Failed to parse ${configName}`);
+      return false;
+    }
+  }
+  if (!foundAny) {
+    return true;
+  }
+  return true;
+}
+function parseTsupEntries(content) {
+  const entries = [];
+  const singleMatch = content.match(/entry\s*:\s*['"]([^'"]+)['"]/);
+  if (singleMatch && singleMatch[1]) {
+    entries.push(singleMatch[1]);
+    return entries;
+  }
+  const entryBlockMatch = content.match(
+    /entry\s*:\s*[\[{]([\s\S]*?)[\]}]/
+  );
+  if (entryBlockMatch && entryBlockMatch[1]) {
+    const block = entryBlockMatch[1];
+    const pathPattern = /['"]([^'"]*?src\/[^'"]+)['"]/g;
+    let match;
+    while ((match = pathPattern.exec(block)) !== null) {
+      if (match[1]) {
+        entries.push(match[1]);
+      }
+    }
+    return entries;
+  }
+  return entries;
+}
+function collectManifestHandlers(packageDir, entryFiles, warnings) {
+  const manifestPath = path4.join(packageDir, "src", "manifest.ts");
+  if (!fs4.existsSync(manifestPath)) {
+    return;
+  }
+  try {
+    const content = fs4.readFileSync(manifestPath, "utf-8");
+    const handlers = parseManifestHandlers(content);
+    for (const handlerPath of handlers) {
+      const pathOnly = handlerPath.split("#")[0] ?? handlerPath;
+      const srcRelative = "src/" + pathOnly.replace(/^\.\//, "").replace(/\.js$/, ".ts");
+      const absolute = path4.resolve(packageDir, srcRelative);
+      if (fs4.existsSync(absolute)) {
+        entryFiles.add(absolute);
+      }
+    }
+    entryFiles.add(manifestPath);
+  } catch {
+    warnings.push("Failed to parse manifest.ts");
+  }
+}
+function parseManifestHandlers(content) {
+  const handlers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pattern = /(?:handler|handlerPath)\s*:\s*['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const matchValue = match[1];
+    if (!matchValue) {
+      continue;
+    }
+    const raw = matchValue.split("#")[0] ?? matchValue;
+    if (!seen.has(raw)) {
+      seen.add(raw);
+      handlers.push(raw);
+    }
+  }
+  return handlers;
+}
+async function collectDynamicImportTargets(packageDir, entryFiles, _warnings) {
+  const srcDir = path4.join(packageDir, "src");
+  if (!fs4.existsSync(srcDir)) {
+    return;
+  }
+  const sourceFiles = await globby("**/*.{ts,tsx}", {
+    cwd: srcDir,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.spec.ts", "**/__tests__/**"]
+  });
+  const dynamicImportPattern = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+  for (const file of sourceFiles) {
+    try {
+      const content = fs4.readFileSync(file, "utf-8");
+      let match;
+      while ((match = dynamicImportPattern.exec(content)) !== null) {
+        const importPath = match[1];
+        if (!importPath) {
+          continue;
+        }
+        const resolved = resolveFilePath(importPath, file);
+        if (resolved) {
+          entryFiles.add(resolved);
+        }
+      }
+    } catch {
+    }
+  }
+}
+async function collectTestFiles(packageDir, aliveByConvention) {
+  const srcDir = path4.join(packageDir, "src");
+  if (!fs4.existsSync(srcDir)) {
+    return;
+  }
+  const testFiles = await globby(
+    ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx", "**/__tests__/**/*.ts"],
+    { cwd: srcDir, absolute: true }
+  );
+  for (const file of testFiles) {
+    aliveByConvention.add(file);
+  }
+}
+function collectConfigFiles(packageDir, aliveByConvention) {
+  for (const pattern of CONFIG_FILE_PATTERNS) {
+    const configPath = path4.join(packageDir, pattern);
+    if (fs4.existsSync(configPath)) {
+      aliveByConvention.add(configPath);
+    }
+  }
+}
+function resolveFilePath(importPath, fromFile) {
+  const dir = path4.dirname(fromFile);
+  const base = path4.resolve(dir, importPath);
+  const tsPath = base.replace(/\.js$/, ".ts");
+  if (fs4.existsSync(tsPath)) {
+    return tsPath;
+  }
+  if (fs4.existsSync(base)) {
+    return base;
+  }
+  if (fs4.existsSync(base + ".ts")) {
+    return base + ".ts";
+  }
+  if (fs4.existsSync(base + ".tsx")) {
+    return base + ".tsx";
+  }
+  if (fs4.existsSync(path4.join(base, "index.ts"))) {
+    return path4.join(base, "index.ts");
+  }
+  return null;
+}
+var IMPORT_PATTERNS = [
+  // Static imports: import X from 'module', import { X } from 'module', import 'module'
+  /import\s+(?:[\w*{}\n\r\t, ]+\s+from\s+)?['"]([^'"]+)['"]/g,
+  // Dynamic imports (string literal): import('./module'), import("./module")
+  /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  // CommonJS require: require('./module'), require("./module")
+  /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  // Re-exports: export { X } from 'module', export * from 'module'
+  /export\s+(?:[\w*{}\n\r\t, ]+\s+)?from\s+['"]([^'"]+)['"]/g
+];
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+function extractFileImports(content) {
+  const imports = [];
+  for (const pattern of IMPORT_PATTERNS) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const specifier = match[1];
+      if (specifier) {
+        imports.push(specifier);
+      }
+    }
+  }
+  return imports;
+}
+function isRelativeImport(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+function resolveRelativeImport(specifier, sourceFile) {
+  const dir = path4.dirname(sourceFile);
+  const basePath = path4.resolve(dir, specifier);
+  if (specifier.endsWith(".js")) {
+    const tsPath = basePath.slice(0, -3) + ".ts";
+    if (fs4.existsSync(tsPath)) {
+      return tsPath;
+    }
+    const tsxPath = basePath.slice(0, -3) + ".tsx";
+    if (fs4.existsSync(tsxPath)) {
+      return tsxPath;
+    }
+  }
+  if (fs4.existsSync(basePath) && fs4.statSync(basePath).isFile()) {
+    return basePath;
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const withExt = basePath + ext;
+    if (fs4.existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  if (fs4.existsSync(basePath) && fs4.statSync(basePath).isDirectory()) {
+    for (const ext of RESOLVE_EXTENSIONS) {
+      const indexPath = path4.join(basePath, "index" + ext);
+      if (fs4.existsSync(indexPath)) {
+        return indexPath;
+      }
+    }
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const indexPath = path4.join(basePath, "index" + ext);
+    if (fs4.existsSync(indexPath)) {
+      return indexPath;
+    }
+  }
+  return null;
+}
+function buildFileImportGraph(sourceFiles) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const file of sourceFiles) {
+    const deps = /* @__PURE__ */ new Set();
+    graph.set(file, deps);
+    try {
+      const content = fs4.readFileSync(file, "utf-8");
+      const imports = extractFileImports(content);
+      for (const specifier of imports) {
+        if (!isRelativeImport(specifier)) {
+          continue;
+        }
+        const resolved = resolveRelativeImport(specifier, file);
+        if (resolved) {
+          deps.add(resolved);
+        }
+      }
+    } catch {
+    }
+  }
+  return graph;
+}
+function findReachableFiles(entryPoints, importGraph) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...entryPoints];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    const deps = importGraph.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        if (!visited.has(dep)) {
+          queue.push(dep);
+        }
+      }
+    }
+  }
+  return visited;
+}
+function countGraphEdges(graph) {
+  let count = 0;
+  for (const deps of graph.values()) {
+    count += deps.size;
+  }
+  return count;
+}
+
+// src/dead-code/scan-dead-files.ts
+async function scanDeadFiles(rootDir, options) {
+  const startTime = Date.now();
+  const packages = findPackagesInMonorepo(rootDir, options?.packageFilter);
+  const results = [];
+  for (const pkg of packages) {
+    const result = await analyzePackage(pkg);
+    if (result) {
+      results.push(result);
+    }
+  }
+  const summary = calculateSummary(results);
+  return {
+    packages: results,
+    summary,
+    duration: Date.now() - startTime
+  };
+}
+function findPackagesInMonorepo(rootDir, filter) {
+  const packages = [];
+  if (!fs4.existsSync(rootDir)) {
+    return packages;
+  }
+  const entries = fs4.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path4.join(rootDir, entry.name);
+    const packagesDir = path4.join(repoPath, "packages");
+    if (!fs4.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs4.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path4.join(packagesDir, pkgDir.name, "package.json");
+      if (!fs4.existsSync(packageJsonPath)) {
+        continue;
+      }
+      try {
+        const pkgJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+        const pkgName = pkgJson.name || pkgDir.name;
+        const packageDir = path4.join(packagesDir, pkgDir.name);
+        const srcDir = path4.join(packageDir, "src");
+        if (!fs4.existsSync(srcDir)) {
+          continue;
+        }
+        if (filter && !pkgName.includes(filter) && !pkgDir.name.includes(filter)) {
+          continue;
+        }
+        packages.push({ packageDir, packageJson: pkgJson, packageName: pkgName });
+      } catch {
+      }
+    }
+  }
+  return packages;
+}
+async function analyzePackage(pkg) {
+  const { packageDir, packageJson, packageName } = pkg;
+  const srcDir = path4.join(packageDir, "src");
+  const allSourceFiles = await globby("**/*.{ts,tsx}", {
+    cwd: srcDir,
+    absolute: true,
+    ignore: ["**/*.d.ts"]
+  });
+  if (allSourceFiles.length === 0) {
+    return null;
+  }
+  const {
+    entryFiles,
+    aliveByConvention,
+    warnings,
+    failOpen
+  } = await collectEntryPoints(packageDir, packageJson);
+  if (failOpen) {
+    return {
+      packageName,
+      packageDir,
+      totalFiles: allSourceFiles.length,
+      aliveFiles: allSourceFiles.length,
+      deadFiles: [],
+      entryPoints: [...entryFiles].map((f) => path4.relative(packageDir, f)),
+      graphEdgeCount: 0,
+      warnings: [...warnings, "FAIL-OPEN: All files treated as alive due to config parse errors"]
+    };
+  }
+  const importGraph = buildFileImportGraph(allSourceFiles);
+  const graphEdgeCount = countGraphEdges(importGraph);
+  const seeds = /* @__PURE__ */ new Set([...entryFiles, ...aliveByConvention]);
+  const reachable = findReachableFiles(seeds, importGraph);
+  const allAlive = /* @__PURE__ */ new Set([...reachable, ...aliveByConvention]);
+  const deadFiles = [];
+  for (const file of allSourceFiles) {
+    if (!allAlive.has(file)) {
+      const stats = safeFileStat(file);
+      deadFiles.push({
+        absolutePath: file,
+        relativePath: path4.relative(packageDir, file),
+        packageName,
+        packageDir,
+        sizeBytes: stats?.size ?? 0
+      });
+    }
+  }
+  deadFiles.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return {
+    packageName,
+    packageDir,
+    totalFiles: allSourceFiles.length,
+    aliveFiles: allSourceFiles.length - deadFiles.length,
+    deadFiles,
+    entryPoints: [...entryFiles].map((f) => path4.relative(packageDir, f)),
+    graphEdgeCount,
+    warnings
+  };
+}
+function calculateSummary(results, rootDir) {
+  let totalFiles = 0;
+  let totalDead = 0;
+  let totalDeadBytes = 0;
+  for (const pkg of results) {
+    totalFiles += pkg.totalFiles;
+    totalDead += pkg.deadFiles.length;
+    for (const deadFile of pkg.deadFiles) {
+      totalDeadBytes += deadFile.sizeBytes;
+    }
+  }
+  const emptyDirectories = findPotentialEmptyDirs(results);
+  return {
+    totalPackages: results.length,
+    totalFiles,
+    totalAlive: totalFiles - totalDead,
+    totalDead,
+    totalDeadBytes,
+    emptyDirectories
+  };
+}
+function findPotentialEmptyDirs(results, _rootDir) {
+  const emptyDirs = [];
+  for (const pkg of results) {
+    if (pkg.deadFiles.length === 0) {
+      continue;
+    }
+    const deadByDir = /* @__PURE__ */ new Map();
+    for (const deadFile of pkg.deadFiles) {
+      const dir = path4.dirname(deadFile.absolutePath);
+      deadByDir.set(dir, (deadByDir.get(dir) ?? 0) + 1);
+    }
+    for (const [dir, deadCount] of deadByDir) {
+      try {
+        const allFiles = fs4.readdirSync(dir);
+        if (allFiles.length === deadCount) {
+          emptyDirs.push(path4.relative(pkg.packageDir, dir));
+        }
+      } catch {
+      }
+    }
+  }
+  return emptyDirs;
+}
+function safeFileStat(filePath) {
+  try {
+    return fs4.statSync(filePath);
+  } catch {
+    return null;
+  }
+}
+var BACKUP_DIR = ".dead-code-backup";
+async function removeDeadFiles(rootDir, scanResult, options) {
+  const dryRun = options?.dryRun ?? false;
+  const backupId = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = path4.join(rootDir, BACKUP_DIR, backupId);
+  const gitSha = safeExec("git rev-parse HEAD", rootDir) ?? "unknown";
+  const gitBranch = safeExec("git rev-parse --abbrev-ref HEAD", rootDir) ?? "unknown";
+  const allDeadFiles = [];
+  for (const pkg of scanResult.packages) {
+    allDeadFiles.push(...pkg.deadFiles);
+  }
+  if (allDeadFiles.length === 0) {
+    return {
+      backupId,
+      backupPath,
+      filesRemoved: 0,
+      bytesRemoved: 0,
+      emptyDirsRemoved: 0,
+      exportsCleanedUp: 0,
+      manifest: {
+        id: backupId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        gitSha,
+        gitBranch,
+        removedFiles: [],
+        removedEmptyDirs: [],
+        cleanedExports: [],
+        totalFilesRemoved: 0,
+        totalBytesRemoved: 0
+      }
+    };
+  }
+  const manifest = {
+    id: backupId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    gitSha,
+    gitBranch,
+    removedFiles: allDeadFiles.map((f) => ({
+      originalPath: f.absolutePath,
+      backupPath: path4.relative(rootDir, f.absolutePath),
+      packageName: f.packageName,
+      sizeBytes: f.sizeBytes
+    })),
+    removedEmptyDirs: [],
+    cleanedExports: [],
+    totalFilesRemoved: allDeadFiles.length,
+    totalBytesRemoved: allDeadFiles.reduce((sum, f) => sum + f.sizeBytes, 0)
+  };
+  if (dryRun) {
+    return {
+      backupId,
+      backupPath,
+      filesRemoved: allDeadFiles.length,
+      bytesRemoved: manifest.totalBytesRemoved,
+      emptyDirsRemoved: scanResult.summary.emptyDirectories.length,
+      exportsCleanedUp: 0,
+      manifest
+    };
+  }
+  const filesDir = path4.join(backupPath, "files");
+  for (const deadFile of allDeadFiles) {
+    const relPath = path4.relative(rootDir, deadFile.absolutePath);
+    const destPath = path4.join(filesDir, relPath);
+    const destDir = path4.dirname(destPath);
+    fs4.mkdirSync(destDir, { recursive: true });
+    fs4.copyFileSync(deadFile.absolutePath, destPath);
+  }
+  fs4.writeFileSync(
+    path4.join(backupPath, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n"
+  );
+  for (const deadFile of allDeadFiles) {
+    fs4.unlinkSync(deadFile.absolutePath);
+  }
+  const removedDirs = [];
+  const deadFileDirs = new Set(allDeadFiles.map((f) => path4.dirname(f.absolutePath)));
+  for (const dir of deadFileDirs) {
+    removeEmptyDirsUpward(dir, rootDir, removedDirs);
+  }
+  manifest.removedEmptyDirs = removedDirs.map((d) => path4.relative(rootDir, d));
+  const deletedPaths = new Set(allDeadFiles.map((f) => f.absolutePath));
+  let exportsCleanedUp = 0;
+  for (const pkg of scanResult.packages) {
+    if (pkg.deadFiles.length === 0) {
+      continue;
+    }
+    const pkgJsonPath = path4.join(pkg.packageDir, "package.json");
+    const cleaned = cleanPackageJsonExports(pkgJsonPath, deletedPaths, pkg.packageDir);
+    if (cleaned.length > 0) {
+      manifest.cleanedExports.push({
+        packageJsonPath: path4.relative(rootDir, pkgJsonPath),
+        removedExportKeys: cleaned
+      });
+      exportsCleanedUp += cleaned.length;
+    }
+  }
+  fs4.writeFileSync(
+    path4.join(backupPath, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n"
+  );
+  return {
+    backupId,
+    backupPath,
+    filesRemoved: allDeadFiles.length,
+    bytesRemoved: manifest.totalBytesRemoved,
+    emptyDirsRemoved: removedDirs.length,
+    exportsCleanedUp,
+    manifest
+  };
+}
+async function restoreFromBackup(rootDir, backupId) {
+  const backupPath = path4.join(rootDir, BACKUP_DIR, backupId);
+  const manifestPath = path4.join(backupPath, "manifest.json");
+  if (!fs4.existsSync(manifestPath)) {
+    throw new Error(`Backup not found: ${backupId}`);
+  }
+  const manifest = JSON.parse(
+    fs4.readFileSync(manifestPath, "utf-8")
+  );
+  let restoredFiles = 0;
+  for (const entry of manifest.removedFiles) {
+    const backupFilePath = path4.join(backupPath, "files", entry.backupPath);
+    if (!fs4.existsSync(backupFilePath)) {
+      continue;
+    }
+    const parentDir = path4.dirname(entry.originalPath);
+    fs4.mkdirSync(parentDir, { recursive: true });
+    fs4.copyFileSync(backupFilePath, entry.originalPath);
+    restoredFiles++;
+  }
+  let restoredExports = 0;
+  for (const exportEntry of manifest.cleanedExports) {
+    const pkgJsonPath = path4.resolve(rootDir, exportEntry.packageJsonPath);
+    if (!fs4.existsSync(pkgJsonPath)) {
+      continue;
+    }
+    restoredExports += exportEntry.removedExportKeys.length;
+  }
+  return { restoredFiles, restoredExports };
+}
+function listBackups(rootDir) {
+  const backupDir = path4.join(rootDir, BACKUP_DIR);
+  if (!fs4.existsSync(backupDir)) {
+    return [];
+  }
+  const backups = [];
+  const entries = fs4.readdirSync(backupDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const manifestPath = path4.join(backupDir, entry.name, "manifest.json");
+    if (!fs4.existsSync(manifestPath)) {
+      continue;
+    }
+    try {
+      const manifest = JSON.parse(
+        fs4.readFileSync(manifestPath, "utf-8")
+      );
+      backups.push(manifest);
+    } catch {
+    }
+  }
+  backups.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  return backups;
+}
+function safeExec(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+  } catch {
+    return null;
+  }
+}
+function removeEmptyDirsUpward(dir, rootBoundary, removed) {
+  let current = dir;
+  while (current !== rootBoundary && current.startsWith(rootBoundary)) {
+    try {
+      const entries = fs4.readdirSync(current);
+      if (entries.length > 0) {
+        break;
+      }
+      fs4.rmdirSync(current);
+      removed.push(current);
+      current = path4.dirname(current);
+    } catch {
+      break;
+    }
+  }
+}
+function cleanPackageJsonExports(packageJsonPath, deletedPaths, packageDir) {
+  if (!fs4.existsSync(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const content = fs4.readFileSync(packageJsonPath, "utf-8");
+    const pkgJson = JSON.parse(content);
+    const removedKeys = [];
+    if (!pkgJson.exports || typeof pkgJson.exports !== "object") {
+      return [];
+    }
+    for (const [key, value] of Object.entries(pkgJson.exports)) {
+      if (key.includes("*")) {
+        continue;
+      }
+      const exportPath = extractExportImportPath(value);
+      if (!exportPath) {
+        continue;
+      }
+      const srcPath = distToSrcForExportCheck(exportPath, packageDir);
+      if (srcPath && deletedPaths.has(srcPath)) {
+        delete pkgJson.exports[key];
+        removedKeys.push(key);
+      }
+    }
+    if (removedKeys.length > 0) {
+      fs4.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+    }
+    return removedKeys;
+  } catch {
+    return [];
+  }
+}
+function extractExportImportPath(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    for (const key of ["import", "default", "require"]) {
+      if (typeof obj[key] === "string") {
+        return obj[key];
+      }
+    }
+  }
+  return null;
+}
+function distToSrcForExportCheck(distPath, packageDir) {
+  let normalized = distPath.replace(/^\.?\/?/, "");
+  if (!normalized.startsWith("dist/") && !normalized.startsWith("dist\\")) {
+    return null;
+  }
+  normalized = "src/" + normalized.slice(5);
+  normalized = normalized.replace(/\.d\.ts$/, ".ts").replace(/\.js$/, ".ts").replace(/\.mjs$/, ".ts").replace(/\.cjs$/, ".ts");
+  return path4.resolve(packageDir, normalized);
+}
+
+export { buildFileImportGraph, collectEntryPoints, distPathToSrcPath, extractFileImports, findReachableFiles, listBackups, parseManifestHandlers, parseTsupEntries, removeDeadFiles, resolveRelativeImport, restoreFromBackup, scanDeadFiles };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map