@kb-labs/quality-core 0.6.0

package/dist/index.js

@@ -0,0 +1,1921 @@
+import fs8 from 'fs';
+import path8, { join } from 'path';
+import { readFile, stat, access } from 'fs/promises';
+import globby3 from 'globby';
+import { exec, execSync } from 'child_process';
+import { promisify } from 'util';
+import ts from 'typescript';
+
+// src/graph/dependency-graph.ts
+function buildDependencyGraph(rootDir) {
+  const nodes = /* @__PURE__ */ new Map();
+  const workspacePackages = /* @__PURE__ */ new Set();
+  if (!fs8.existsSync(rootDir)) {
+    return { nodes, workspacePackages };
+  }
+  const entries = fs8.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        const packageName = pkgJson.name;
+        if (packageName) {
+          workspacePackages.add(packageName);
+        }
+      }
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        const packageName = pkgJson.name;
+        if (!packageName) {
+          continue;
+        }
+        const deps = /* @__PURE__ */ new Set();
+        const devDeps = /* @__PURE__ */ new Set();
+        const allDeps = {
+          ...pkgJson.dependencies,
+          ...pkgJson.devDependencies
+        };
+        for (const dep of Object.keys(allDeps)) {
+          if (workspacePackages.has(dep)) {
+            deps.add(dep);
+          }
+        }
+        if (pkgJson.devDependencies) {
+          for (const dep of Object.keys(pkgJson.devDependencies)) {
+            if (workspacePackages.has(dep)) {
+              devDeps.add(dep);
+            }
+          }
+        }
+        nodes.set(packageName, {
+          name: packageName,
+          path: packageJsonPath,
+          dir: path8.dirname(packageJsonPath),
+          deps,
+          devDeps,
+          dependents: /* @__PURE__ */ new Set()
+        });
+      }
+    }
+  }
+  for (const [packageName, node] of nodes) {
+    for (const dep of node.deps) {
+      const depNode = nodes.get(dep);
+      if (depNode) {
+        depNode.dependents.add(packageName);
+      }
+    }
+  }
+  return { nodes, workspacePackages };
+}
+function topologicalSort(graph) {
+  const { nodes } = graph;
+  const layers = [];
+  const sorted = [];
+  const circular = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const [name] of nodes) {
+    inDegree.set(name, 0);
+  }
+  for (const [, node] of nodes) {
+    for (const dep of node.deps) {
+      if (nodes.has(dep)) {
+        inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  while (queue.length > 0) {
+    const layer = [...queue];
+    layers.push(layer);
+    sorted.push(...layer);
+    queue.length = 0;
+    for (const name of layer) {
+      const node = nodes.get(name);
+      if (!node) {
+        continue;
+      }
+      for (const dep of node.deps) {
+        if (nodes.has(dep)) {
+          const newDegree = (inDegree.get(dep) ?? 0) - 1;
+          inDegree.set(dep, newDegree);
+          if (newDegree === 0) {
+            queue.push(dep);
+          }
+        }
+      }
+    }
+  }
+  if (sorted.length < nodes.size) {
+    const remaining = /* @__PURE__ */ new Set();
+    for (const [name] of nodes) {
+      if (!sorted.includes(name)) {
+        remaining.add(name);
+      }
+    }
+    const cycles = findCircularDependencies(graph, remaining);
+    circular.push(...cycles);
+  }
+  return { layers, sorted, circular };
+}
+function findCircularDependencies(graph, subset) {
+  const { nodes } = graph;
+  const visited = /* @__PURE__ */ new Set();
+  const recStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  function dfs(node, path9) {
+    visited.add(node);
+    recStack.add(node);
+    path9.push(node);
+    const nodeData = nodes.get(node);
+    if (!nodeData) {
+      return;
+    }
+    for (const dep of nodeData.deps) {
+      if (!nodes.has(dep)) {
+        continue;
+      }
+      if (subset && !subset.has(dep)) {
+        continue;
+      }
+      if (!visited.has(dep)) {
+        dfs(dep, [...path9]);
+      } else if (recStack.has(dep)) {
+        const cycleStart = path9.indexOf(dep);
+        if (cycleStart !== -1) {
+          const cycle = path9.slice(cycleStart);
+          cycles.push([...cycle, dep]);
+        }
+      }
+    }
+    recStack.delete(node);
+  }
+  const nodesToCheck = subset ?? new Set(nodes.keys());
+  for (const node of nodesToCheck) {
+    if (!visited.has(node)) {
+      dfs(node, []);
+    }
+  }
+  return cycles;
+}
+function getBuildOrderForPackage(graph, packageName) {
+  const { nodes } = graph;
+  const allDeps = /* @__PURE__ */ new Set();
+  const queue = [packageName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    allDeps.add(current);
+    const node = nodes.get(current);
+    if (!node) {
+      continue;
+    }
+    for (const dep of node.deps) {
+      if (!allDeps.has(dep) && nodes.has(dep)) {
+        queue.push(dep);
+      }
+    }
+  }
+  const subgraph = {
+    nodes: /* @__PURE__ */ new Map(),
+    workspacePackages: graph.workspacePackages
+  };
+  for (const pkg of allDeps) {
+    const node = nodes.get(pkg);
+    if (node) {
+      subgraph.nodes.set(pkg, node);
+    }
+  }
+  return topologicalSort(subgraph);
+}
+function getReverseDependencies(graph, packageName) {
+  const { nodes } = graph;
+  const reverseDeps = /* @__PURE__ */ new Set();
+  for (const [name, node] of nodes) {
+    if (node.deps.has(packageName)) {
+      reverseDeps.add(name);
+    }
+  }
+  return reverseDeps;
+}
+function getImpactAnalysis(graph, packageName) {
+  const affected = /* @__PURE__ */ new Set();
+  const queue = [packageName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const reverseDeps = getReverseDependencies(graph, current);
+    for (const dep of reverseDeps) {
+      if (!affected.has(dep)) {
+        affected.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return affected;
+}
+async function calculateLinesOfCode(rootDir, sourceFiles) {
+  const files = sourceFiles ?? await globby3("**/*.{ts,tsx,js,jsx}", {
+    cwd: rootDir,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/.git/**",
+      "**/.kb/**",
+      "**/build/**",
+      "**/*.test.{ts,tsx,js,jsx}",
+      "**/*.spec.{ts,tsx,js,jsx}"
+    ],
+    absolute: true,
+    deep: 8
+  });
+  const contents = await Promise.all(files.map((f) => readFile(f, "utf-8").catch(() => null)));
+  return contents.reduce((sum, c) => sum + (c ? c.split("\n").length : 0), 0);
+}
+async function calculateSize(rootDir, sourceFiles) {
+  const files = sourceFiles ?? await globby3("**/*.{ts,tsx,js,jsx}", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.kb/**", "**/build/**"],
+    absolute: true,
+    deep: 8
+  });
+  const stats = await Promise.all(files.map((f) => stat(f).catch(() => null)));
+  return stats.reduce((sum, s) => sum + (s ? s.size : 0), 0);
+}
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  return `${value.toFixed(2)} ${units[i]}`;
+}
+async function countPackages(rootDir) {
+  const packageJsonFiles = await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.kb/**"],
+    absolute: false,
+    deep: 6
+  });
+  return packageJsonFiles.filter((p) => p !== "package.json").length;
+}
+async function calculateStats(rootDir) {
+  const sourceFiles = await globby3("**/*.{ts,tsx,js,jsx}", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/.kb/**", "**/build/**"],
+    absolute: true,
+    deep: 8
+  });
+  const [packages, loc, size] = await Promise.all([
+    countPackages(rootDir),
+    calculateLinesOfCode(rootDir, sourceFiles),
+    calculateSize(rootDir, sourceFiles)
+  ]);
+  return {
+    packages,
+    loc,
+    size,
+    sizeFormatted: formatBytes(size)
+  };
+}
+async function checkDuplicateDependencies(rootDir, pkgFiles) {
+  const packageJsonFiles = pkgFiles ?? await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**"],
+    absolute: true
+  });
+  const depVersions = /* @__PURE__ */ new Map();
+  const contents = await Promise.all(
+    packageJsonFiles.map((f) => readFile(f, "utf-8").catch(() => null))
+  );
+  for (const content of contents) {
+    if (!content) {
+      continue;
+    }
+    try {
+      const pkg = JSON.parse(content);
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      for (const [name, version] of Object.entries(allDeps)) {
+        if (typeof version !== "string") {
+          continue;
+        }
+        if (!depVersions.has(name)) {
+          depVersions.set(name, /* @__PURE__ */ new Set());
+        }
+        depVersions.get(name).add(version);
+      }
+    } catch {
+    }
+  }
+  const duplicates = Array.from(depVersions.entries()).filter(
+    ([, versions]) => versions.size > 1
+  );
+  if (duplicates.length === 0) {
+    return null;
+  }
+  const penalty = Math.min(duplicates.length * 2, 30);
+  return {
+    type: "duplicate",
+    severity: duplicates.length > 20 ? "high" : duplicates.length > 10 ? "medium" : "low",
+    message: `Found ${duplicates.length} duplicate dependencies with different versions`,
+    count: duplicates.length,
+    penalty
+  };
+}
+async function checkMissingReadmes(rootDir, packageJsonFiles) {
+  const pkgFiles = packageJsonFiles ?? await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**", "package.json"],
+    absolute: true
+  });
+  const hasReadme = async (pkgPath) => {
+    const dir = join(pkgPath, "..");
+    for (const name of ["README.md", "readme.md", "Readme.md"]) {
+      try {
+        await access(join(dir, name));
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  };
+  const results = await Promise.all(pkgFiles.map(hasReadme));
+  const missingCount = results.filter((has) => !has).length;
+  if (missingCount === 0) {
+    return null;
+  }
+  const penalty = Math.min(missingCount, 15);
+  return {
+    type: "readme",
+    severity: missingCount > 20 ? "high" : missingCount > 10 ? "medium" : "low",
+    message: `Found ${missingCount} packages without README`,
+    count: missingCount,
+    penalty
+  };
+}
+function calculateHealthScore(issues) {
+  const baseScore = 100;
+  const totalPenalty = issues.reduce((sum, issue) => sum + issue.penalty, 0);
+  return Math.max(0, baseScore - totalPenalty);
+}
+function scoreToGrade(score) {
+  if (score >= 90) {
+    return "A";
+  }
+  if (score >= 80) {
+    return "B";
+  }
+  if (score >= 70) {
+    return "C";
+  }
+  if (score >= 60) {
+    return "D";
+  }
+  return "F";
+}
+async function calculateHealth(rootDir) {
+  const issues = [];
+  const packageJsonFiles = await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.kb/**", "**/dist/**"],
+    absolute: true,
+    deep: 6
+  });
+  const [duplicatesIssue, readmesIssue] = await Promise.all([
+    checkDuplicateDependencies(rootDir, packageJsonFiles),
+    checkMissingReadmes(rootDir, packageJsonFiles)
+  ]);
+  if (duplicatesIssue) {
+    issues.push(duplicatesIssue);
+  }
+  if (readmesIssue) {
+    issues.push(readmesIssue);
+  }
+  const score = calculateHealthScore(issues);
+  const grade = scoreToGrade(score);
+  return {
+    score,
+    grade,
+    issues
+  };
+}
+async function analyzeDuplicateDependencies(rootDir) {
+  const packageJsonFiles = await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**"],
+    absolute: true
+  });
+  const depVersionMap = /* @__PURE__ */ new Map();
+  for (const file of packageJsonFiles) {
+    try {
+      const content = await readFile(file, "utf-8");
+      const pkg = JSON.parse(content);
+      const pkgName = pkg.name || file;
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      for (const [name, version] of Object.entries(allDeps)) {
+        if (typeof version !== "string") {
+          continue;
+        }
+        if (!depVersionMap.has(name)) {
+          depVersionMap.set(name, /* @__PURE__ */ new Map());
+        }
+        const versionMap = depVersionMap.get(name);
+        if (!versionMap.has(version)) {
+          versionMap.set(version, []);
+        }
+        versionMap.get(version).push(pkgName);
+      }
+    } catch {
+    }
+  }
+  const duplicates = [];
+  for (const [name, versionMap] of depVersionMap) {
+    if (versionMap.size <= 1) {
+      continue;
+    }
+    const versions = Array.from(versionMap.entries()).map(
+      ([version, packages]) => ({
+        version,
+        packages,
+        count: packages.length
+      })
+    );
+    versions.sort((a, b) => b.count - a.count);
+    const totalPackages = versions.reduce((sum, v) => sum + v.count, 0);
+    duplicates.push({
+      name,
+      versions,
+      totalPackages
+    });
+  }
+  duplicates.sort((a, b) => b.totalPackages - a.totalPackages);
+  return duplicates;
+}
+async function analyzeUnusedDependencies(rootDir) {
+  const packageJsonFiles = await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**"],
+    absolute: true
+  });
+  const unused = [];
+  for (const pkgPath of packageJsonFiles) {
+    try {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      const pkgName = pkg.name || pkgPath;
+      const pkgDir = join(pkgPath, "..");
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      const sourceFiles = await globby3("src/**/*.{ts,tsx,js,jsx}", {
+        cwd: pkgDir,
+        absolute: true,
+        ignore: ["**/*.test.*", "**/*.spec.*"]
+      });
+      const sourceContents = await Promise.all(
+        sourceFiles.map(async (file) => {
+          try {
+            return readFile(file, "utf-8");
+          } catch {
+            return "";
+          }
+        })
+      );
+      const allSource = sourceContents.join("\n");
+      for (const depName of Object.keys(allDeps)) {
+        if (depName.startsWith("@types/") || depName === "typescript" || depName === "tsup" || depName === "vitest" || depName === "eslint" || depName === "prettier") {
+          continue;
+        }
+        if (!allSource.includes(depName)) {
+          const existing = unused.find((u) => u.name === depName);
+          if (existing) {
+            existing.packages.push(pkgName);
+          } else {
+            unused.push({
+              name: depName,
+              packages: [pkgName]
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return unused;
+}
+async function analyzeMissingDependencies(rootDir) {
+  const packageJsonFiles = await globby3("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "**/.git/**"],
+    absolute: true
+  });
+  const workspacePackages = /* @__PURE__ */ new Set();
+  for (const file of packageJsonFiles) {
+    try {
+      const content = await readFile(file, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.name) {
+        workspacePackages.add(pkg.name);
+      }
+    } catch {
+    }
+  }
+  const missing = [];
+  for (const pkgPath of packageJsonFiles) {
+    try {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (!pkg.name) {
+        continue;
+      }
+      const pkgName = pkg.name;
+      const pkgDir = join(pkgPath, "..");
+      const declaredDeps = /* @__PURE__ */ new Set([
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.devDependencies || {})
+      ]);
+      const sourceFiles = await globby3("src/**/*.{ts,tsx,js,jsx}", {
+        cwd: pkgDir,
+        absolute: true
+      });
+      for (const file of sourceFiles) {
+        try {
+          const source = await readFile(file, "utf-8");
+          const importRegex = /from\s+['"](@[\w-]+\/[\w-]+|[\w-]+)['"]/g;
+          let match;
+          while ((match = importRegex.exec(source)) !== null) {
+            const importedPkg = match[1];
+            if (!importedPkg) {
+              continue;
+            }
+            if (workspacePackages.has(importedPkg) && !declaredDeps.has(importedPkg)) {
+              const existing = missing.find((m) => m.name === importedPkg);
+              if (existing) {
+                if (!existing.packages.includes(pkgName)) {
+                  existing.packages.push(pkgName);
+                }
+                if (!existing.importedIn.includes(file)) {
+                  existing.importedIn.push(file);
+                }
+              } else {
+                missing.push({
+                  name: importedPkg,
+                  packages: [pkgName],
+                  importedIn: [file]
+                });
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return missing;
+}
+async function analyzeDependencies(rootDir) {
+  const [duplicates, unused, missing] = await Promise.all([
+    analyzeDuplicateDependencies(rootDir),
+    analyzeUnusedDependencies(rootDir),
+    analyzeMissingDependencies(rootDir)
+  ]);
+  return {
+    duplicates,
+    unused,
+    missing
+  };
+}
+var execAsync = promisify(exec);
+function findPackagesWithBuildScript(rootDir, filter) {
+  const packages = [];
+  if (!fs8.existsSync(rootDir)) {
+    return packages;
+  }
+  const entries = fs8.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        if (!pkgJson.scripts?.build) {
+          continue;
+        }
+        if (filter && !pkgJson.name.includes(filter) && !pkgDir.name.includes(filter)) {
+          continue;
+        }
+        packages.push(packageJsonPath);
+      }
+    }
+  }
+  return packages;
+}
+function isDistStale(packageDir) {
+  const distFile = path8.join(packageDir, "dist/index.js");
+  const srcDir = path8.join(packageDir, "src");
+  if (!fs8.existsSync(distFile)) {
+    return { stale: false };
+  }
+  if (!fs8.existsSync(srcDir)) {
+    return { stale: false };
+  }
+  const distMtime = fs8.statSync(distFile).mtime.getTime();
+  let newestSrcMtime = 0;
+  function walkDir(dir) {
+    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(fullPath);
+      } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+        const mtime = fs8.statSync(fullPath).mtime.getTime();
+        if (mtime > newestSrcMtime) {
+          newestSrcMtime = mtime;
+        }
+      }
+    }
+  }
+  walkDir(srcDir);
+  return {
+    stale: newestSrcMtime > distMtime,
+    distMtime,
+    srcMtime: newestSrcMtime
+  };
+}
+async function tryBuildPackage(packageDir, packageName, timeout) {
+  try {
+    await execAsync("pnpm run build", {
+      cwd: packageDir,
+      timeout,
+      encoding: "utf-8"
+    });
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err.stderr?.trim() || err.message,
+      exitCode: err.code || 1
+    };
+  }
+}
+async function checkBuilds(rootDir, options = {}) {
+  const startTime = Date.now();
+  const timeout = options.timeout || 3e4;
+  const packagePaths = findPackagesWithBuildScript(rootDir, options.packageFilter);
+  const result = {
+    totalPackages: packagePaths.length,
+    passing: 0,
+    failing: 0,
+    failures: [],
+    staleBuilds: [],
+    duration: 0
+  };
+  for (const pkgPath of packagePaths) {
+    const pkgJson = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+    const packageName = pkgJson.name;
+    const packageDir = path8.dirname(pkgPath);
+    const staleCheck = isDistStale(packageDir);
+    if (staleCheck.stale) {
+      result.staleBuilds.push({
+        package: packageName,
+        distMtime: staleCheck.distMtime,
+        srcMtime: staleCheck.srcMtime
+      });
+    }
+    const buildResult = await tryBuildPackage(packageDir, packageName, timeout);
+    if (buildResult.success) {
+      result.passing++;
+    } else {
+      result.failing++;
+      result.failures.push({
+        package: packageName,
+        error: buildResult.error,
+        exitCode: buildResult.exitCode
+      });
+    }
+  }
+  result.duration = Date.now() - startTime;
+  return result;
+}
+function findPackagesWithTsConfig(rootDir, filter) {
+  const packages = [];
+  if (!fs8.existsSync(rootDir)) {
+    return packages;
+  }
+  const entries = fs8.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const tsconfigPath = path8.join(packagesDir, pkgDir.name, "tsconfig.json");
+      if (fs8.existsSync(packageJsonPath) && fs8.existsSync(tsconfigPath)) {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        if (filter && !pkgJson.name.includes(filter) && !pkgDir.name.includes(filter)) {
+          continue;
+        }
+        packages.push({
+          name: pkgJson.name,
+          dir: path8.dirname(packageJsonPath),
+          tsconfigPath
+        });
+      }
+    }
+  }
+  return packages;
+}
+function createProgram(packageDir, tsconfigPath) {
+  try {
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (configFile.error) {
+      return null;
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      packageDir
+    );
+    if (parsedConfig.errors.length > 0) {
+      return null;
+    }
+    return ts.createProgram({
+      rootNames: parsedConfig.fileNames,
+      options: parsedConfig.options
+    });
+  } catch (err) {
+    return null;
+  }
+}
+function analyzePackageTypes(program) {
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+  let errors = 0;
+  let warnings = 0;
+  for (const diagnostic of diagnostics) {
+    if (!diagnostic.file) {
+      continue;
+    }
+    if (diagnostic.category === ts.DiagnosticCategory.Error) {
+      errors++;
+    } else {
+      warnings++;
+    }
+  }
+  return { errors, warnings };
+}
+function calculateTypeCoverage(program) {
+  const checker = program.getTypeChecker();
+  const sourceFiles = program.getSourceFiles().filter(
+    (sf) => !sf.isDeclarationFile && !sf.fileName.includes("node_modules")
+  );
+  let totalSymbols = 0;
+  let typedSymbols = 0;
+  let anyCount = 0;
+  let tsIgnoreCount = 0;
+  for (const sourceFile of sourceFiles) {
+    const text = sourceFile.getFullText();
+    const tsIgnoreMatches = text.match(/@ts-ignore/g);
+    tsIgnoreCount += tsIgnoreMatches ? tsIgnoreMatches.length : 0;
+    ts.forEachChild(sourceFile, function visit(node) {
+      if (ts.isTypeNode(node)) {
+        totalSymbols++;
+        const type = checker.getTypeAtLocation(node);
+        if (type.flags & ts.TypeFlags.Any) {
+          anyCount++;
+        } else {
+          typedSymbols++;
+        }
+      }
+      ts.forEachChild(node, visit);
+    });
+  }
+  const coverage = totalSymbols > 0 ? typedSymbols / totalSymbols * 100 : 100;
+  return {
+    coverage: Math.round(coverage * 10) / 10,
+    totalSymbols,
+    typedSymbols,
+    anyCount,
+    tsIgnoreCount
+  };
+}
+async function analyzeTypes(rootDir, options = {}) {
+  const startTime = Date.now();
+  const packages = findPackagesWithTsConfig(rootDir, options.packageFilter);
+  const result = {
+    totalPackages: packages.length,
+    packagesWithErrors: 0,
+    totalErrors: 0,
+    totalWarnings: 0,
+    avgCoverage: 0,
+    packages: [],
+    duration: 0
+  };
+  for (const { name, dir, tsconfigPath } of packages) {
+    const program = createProgram(dir, tsconfigPath);
+    if (!program) {
+      continue;
+    }
+    const { errors, warnings } = analyzePackageTypes(program);
+    const coverage = calculateTypeCoverage(program);
+    result.totalErrors += errors;
+    result.totalWarnings += warnings;
+    if (errors > 0) {
+      result.packagesWithErrors++;
+    }
+    result.packages.push({
+      name,
+      errors,
+      warnings,
+      coverage: coverage.coverage,
+      anyCount: coverage.anyCount,
+      tsIgnoreCount: coverage.tsIgnoreCount
+    });
+  }
+  if (result.packages.length > 0) {
+    result.avgCoverage = result.packages.reduce((sum, p) => sum + p.coverage, 0) / result.packages.length;
+    result.avgCoverage = Math.round(result.avgCoverage * 10) / 10;
+  }
+  result.duration = Date.now() - startTime;
+  return result;
+}
+var execAsync2 = promisify(exec);
+function findPackagesWithTests(rootDir, filter) {
+  const packages = [];
+  if (!fs8.existsSync(rootDir)) {
+    return packages;
+  }
+  const entries = fs8.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      if (fs8.existsSync(packageJsonPath)) {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        if (filter && !pkgJson.name.includes(filter) && !pkgDir.name.includes(filter)) {
+          continue;
+        }
+        packages.push({
+          name: pkgJson.name,
+          dir: path8.dirname(packageJsonPath),
+          hasTestScript: !!pkgJson.scripts?.test
+        });
+      }
+    }
+  }
+  return packages;
+}
+async function runPackageTests(packageDir, packageName, timeout) {
+  try {
+    const { stdout, stderr } = await execAsync2("pnpm test", {
+      cwd: packageDir,
+      timeout,
+      env: { ...process.env, CI: "true" }
+      // CI mode for non-interactive tests
+    });
+    return {
+      success: true,
+      exitCode: 0,
+      output: (stdout || "") + (stderr || "")
+    };
+  } catch (err) {
+    return {
+      success: false,
+      exitCode: err.code || 1,
+      error: err.message || "Test execution failed",
+      output: (err.stdout || "") + (err.stderr || "")
+    };
+  }
+}
+function parseTestOutput(output) {
+  const vitestMatch = output.match(/Test Files\s+(\d+)\s+passed/);
+  const jestMatch = output.match(/Tests:\s+(\d+)\s+passed,\s+(\d+)\s+total/);
+  const jestFailMatch = output.match(/(\d+)\s+failed,\s+(\d+)\s+passed,\s+(\d+)\s+total/);
+  if (jestFailMatch && jestFailMatch[1] && jestFailMatch[2] && jestFailMatch[3]) {
+    return {
+      failed: parseInt(jestFailMatch[1], 10),
+      passed: parseInt(jestFailMatch[2], 10),
+      total: parseInt(jestFailMatch[3], 10)
+    };
+  }
+  if (jestMatch && jestMatch[1] && jestMatch[2]) {
+    return {
+      passed: parseInt(jestMatch[1], 10),
+      total: parseInt(jestMatch[2], 10)
+    };
+  }
+  if (vitestMatch && vitestMatch[1]) {
+    return {
+      passed: parseInt(vitestMatch[1], 10),
+      total: parseInt(vitestMatch[1], 10)
+    };
+  }
+  return {};
+}
+function readCoverage(packageDir) {
+  const coveragePath = path8.join(packageDir, "coverage", "coverage-summary.json");
+  if (!fs8.existsSync(coveragePath)) {
+    return null;
+  }
+  try {
+    const coverageData = JSON.parse(fs8.readFileSync(coveragePath, "utf-8"));
+    const total = coverageData.total;
+    return {
+      lines: total?.lines?.pct || 0,
+      statements: total?.statements?.pct || 0,
+      functions: total?.functions?.pct || 0,
+      branches: total?.branches?.pct || 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function runTests(rootDir, options = {}) {
+  const startTime = Date.now();
+  const timeout = options.timeout || 6e4;
+  const packages = findPackagesWithTests(rootDir, options.packageFilter);
+  const result = {
+    totalPackages: packages.length,
+    passing: 0,
+    failing: 0,
+    skipped: 0,
+    failures: [],
+    summary: {
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0
+    },
+    coverage: {
+      avgCoverage: 0,
+      packages: []
+    },
+    duration: 0
+  };
+  for (const { name, dir, hasTestScript } of packages) {
+    if (!hasTestScript) {
+      result.skipped++;
+      continue;
+    }
+    if (options.coverageOnly) {
+      const coverage = readCoverage(dir);
+      if (coverage) {
+        result.coverage.packages.push({
+          name,
+          ...coverage
+        });
+      }
+      continue;
+    }
+    const testResult = await runPackageTests(dir, name, timeout);
+    if (testResult.success) {
+      result.passing++;
+      if (testResult.output) {
+        const counts = parseTestOutput(testResult.output);
+        if (counts.total) {
+          result.summary.totalTests += counts.total;
+        }
+        if (counts.passed) {
+          result.summary.passedTests += counts.passed;
+        }
+        if (counts.failed) {
+          result.summary.failedTests += counts.failed || 0;
+        }
+      }
+    } else {
+      result.failing++;
+      const counts = testResult.output ? parseTestOutput(testResult.output) : {};
+      result.failures.push({
+        package: name,
+        error: testResult.error || "Unknown error",
+        exitCode: testResult.exitCode,
+        failedTests: counts.failed,
+        totalTests: counts.total
+      });
+      if (counts.total) {
+        result.summary.totalTests += counts.total;
+      }
+      if (counts.passed) {
+        result.summary.passedTests += counts.passed || 0;
+      }
+      if (counts.failed) {
+        result.summary.failedTests += counts.failed;
+      }
+    }
+    if (options.withCoverage) {
+      const coverage = readCoverage(dir);
+      if (coverage) {
+        result.coverage.packages.push({
+          name,
+          ...coverage
+        });
+      }
+    }
+  }
+  if (result.coverage.packages.length > 0) {
+    const totalLines = result.coverage.packages.reduce((sum, pkg) => sum + pkg.lines, 0);
+    result.coverage.avgCoverage = totalLines / result.coverage.packages.length;
+  }
+  result.duration = Date.now() - startTime;
+  return result;
+}
+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 = path8.join(packageDir, "src", "index.ts");
+    if (fs8.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 = path8.resolve(packageDir, normalized);
+  if (fs8.existsSync(absolute)) {
+    return absolute;
+  }
+  const indexPath = path8.join(absolute.replace(/\.ts$/, ""), "index.ts");
+  if (fs8.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 = path8.join(packageDir, configName);
+    if (!fs8.existsSync(configPath)) {
+      continue;
+    }
+    foundAny = true;
+    try {
+      const content = fs8.readFileSync(configPath, "utf-8");
+      const entries = parseTsupEntries(content);
+      for (const entry of entries) {
+        if (entry.includes("*") || entry.includes("{")) {
+          const expanded = await globby3(entry, {
+            cwd: packageDir,
+            absolute: true
+          });
+          for (const file of expanded) {
+            entryFiles.add(file);
+          }
+        } else {
+          const absolute = path8.resolve(packageDir, entry);
+          if (fs8.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 = path8.join(packageDir, "src", "manifest.ts");
+  if (!fs8.existsSync(manifestPath)) {
+    return;
+  }
+  try {
+    const content = fs8.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 = path8.resolve(packageDir, srcRelative);
+      if (fs8.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 = path8.join(packageDir, "src");
+  if (!fs8.existsSync(srcDir)) {
+    return;
+  }
+  const sourceFiles = await globby3("**/*.{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 = fs8.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 = path8.join(packageDir, "src");
+  if (!fs8.existsSync(srcDir)) {
+    return;
+  }
+  const testFiles = await globby3(
+    ["**/*.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 = path8.join(packageDir, pattern);
+    if (fs8.existsSync(configPath)) {
+      aliveByConvention.add(configPath);
+    }
+  }
+}
+function resolveFilePath(importPath, fromFile) {
+  const dir = path8.dirname(fromFile);
+  const base = path8.resolve(dir, importPath);
+  const tsPath = base.replace(/\.js$/, ".ts");
+  if (fs8.existsSync(tsPath)) {
+    return tsPath;
+  }
+  if (fs8.existsSync(base)) {
+    return base;
+  }
+  if (fs8.existsSync(base + ".ts")) {
+    return base + ".ts";
+  }
+  if (fs8.existsSync(base + ".tsx")) {
+    return base + ".tsx";
+  }
+  if (fs8.existsSync(path8.join(base, "index.ts"))) {
+    return path8.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 = path8.dirname(sourceFile);
+  const basePath = path8.resolve(dir, specifier);
+  if (specifier.endsWith(".js")) {
+    const tsPath = basePath.slice(0, -3) + ".ts";
+    if (fs8.existsSync(tsPath)) {
+      return tsPath;
+    }
+    const tsxPath = basePath.slice(0, -3) + ".tsx";
+    if (fs8.existsSync(tsxPath)) {
+      return tsxPath;
+    }
+  }
+  if (fs8.existsSync(basePath) && fs8.statSync(basePath).isFile()) {
+    return basePath;
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const withExt = basePath + ext;
+    if (fs8.existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  if (fs8.existsSync(basePath) && fs8.statSync(basePath).isDirectory()) {
+    for (const ext of RESOLVE_EXTENSIONS) {
+      const indexPath = path8.join(basePath, "index" + ext);
+      if (fs8.existsSync(indexPath)) {
+        return indexPath;
+      }
+    }
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    const indexPath = path8.join(basePath, "index" + ext);
+    if (fs8.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 = fs8.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 (!fs8.existsSync(rootDir)) {
+    return packages;
+  }
+  const entries = fs8.readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
+      continue;
+    }
+    const repoPath = path8.join(rootDir, entry.name);
+    const packagesDir = path8.join(repoPath, "packages");
+    if (!fs8.existsSync(packagesDir)) {
+      continue;
+    }
+    const packageDirs = fs8.readdirSync(packagesDir, { withFileTypes: true });
+    for (const pkgDir of packageDirs) {
+      if (!pkgDir.isDirectory()) {
+        continue;
+      }
+      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      if (!fs8.existsSync(packageJsonPath)) {
+        continue;
+      }
+      try {
+        const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
+        const pkgName = pkgJson.name || pkgDir.name;
+        const packageDir = path8.join(packagesDir, pkgDir.name);
+        const srcDir = path8.join(packageDir, "src");
+        if (!fs8.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 = path8.join(packageDir, "src");
+  const allSourceFiles = await globby3("**/*.{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) => path8.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: path8.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) => path8.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 = path8.dirname(deadFile.absolutePath);
+      deadByDir.set(dir, (deadByDir.get(dir) ?? 0) + 1);
+    }
+    for (const [dir, deadCount] of deadByDir) {
+      try {
+        const allFiles = fs8.readdirSync(dir);
+        if (allFiles.length === deadCount) {
+          emptyDirs.push(path8.relative(pkg.packageDir, dir));
+        }
+      } catch {
+      }
+    }
+  }
+  return emptyDirs;
+}
+function safeFileStat(filePath) {
+  try {
+    return fs8.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 = path8.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: path8.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 = path8.join(backupPath, "files");
+  for (const deadFile of allDeadFiles) {
+    const relPath = path8.relative(rootDir, deadFile.absolutePath);
+    const destPath = path8.join(filesDir, relPath);
+    const destDir = path8.dirname(destPath);
+    fs8.mkdirSync(destDir, { recursive: true });
+    fs8.copyFileSync(deadFile.absolutePath, destPath);
+  }
+  fs8.writeFileSync(
+    path8.join(backupPath, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n"
+  );
+  for (const deadFile of allDeadFiles) {
+    fs8.unlinkSync(deadFile.absolutePath);
+  }
+  const removedDirs = [];
+  const deadFileDirs = new Set(allDeadFiles.map((f) => path8.dirname(f.absolutePath)));
+  for (const dir of deadFileDirs) {
+    removeEmptyDirsUpward(dir, rootDir, removedDirs);
+  }
+  manifest.removedEmptyDirs = removedDirs.map((d) => path8.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 = path8.join(pkg.packageDir, "package.json");
+    const cleaned = cleanPackageJsonExports(pkgJsonPath, deletedPaths, pkg.packageDir);
+    if (cleaned.length > 0) {
+      manifest.cleanedExports.push({
+        packageJsonPath: path8.relative(rootDir, pkgJsonPath),
+        removedExportKeys: cleaned
+      });
+      exportsCleanedUp += cleaned.length;
+    }
+  }
+  fs8.writeFileSync(
+    path8.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 = path8.join(rootDir, BACKUP_DIR, backupId);
+  const manifestPath = path8.join(backupPath, "manifest.json");
+  if (!fs8.existsSync(manifestPath)) {
+    throw new Error(`Backup not found: ${backupId}`);
+  }
+  const manifest = JSON.parse(
+    fs8.readFileSync(manifestPath, "utf-8")
+  );
+  let restoredFiles = 0;
+  for (const entry of manifest.removedFiles) {
+    const backupFilePath = path8.join(backupPath, "files", entry.backupPath);
+    if (!fs8.existsSync(backupFilePath)) {
+      continue;
+    }
+    const parentDir = path8.dirname(entry.originalPath);
+    fs8.mkdirSync(parentDir, { recursive: true });
+    fs8.copyFileSync(backupFilePath, entry.originalPath);
+    restoredFiles++;
+  }
+  let restoredExports = 0;
+  for (const exportEntry of manifest.cleanedExports) {
+    const pkgJsonPath = path8.resolve(rootDir, exportEntry.packageJsonPath);
+    if (!fs8.existsSync(pkgJsonPath)) {
+      continue;
+    }
+    restoredExports += exportEntry.removedExportKeys.length;
+  }
+  return { restoredFiles, restoredExports };
+}
+function listBackups(rootDir) {
+  const backupDir = path8.join(rootDir, BACKUP_DIR);
+  if (!fs8.existsSync(backupDir)) {
+    return [];
+  }
+  const backups = [];
+  const entries = fs8.readdirSync(backupDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const manifestPath = path8.join(backupDir, entry.name, "manifest.json");
+    if (!fs8.existsSync(manifestPath)) {
+      continue;
+    }
+    try {
+      const manifest = JSON.parse(
+        fs8.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 = fs8.readdirSync(current);
+      if (entries.length > 0) {
+        break;
+      }
+      fs8.rmdirSync(current);
+      removed.push(current);
+      current = path8.dirname(current);
+    } catch {
+      break;
+    }
+  }
+}
+function cleanPackageJsonExports(packageJsonPath, deletedPaths, packageDir) {
+  if (!fs8.existsSync(packageJsonPath)) {
+    return [];
+  }
+  try {
+    const content = fs8.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) {
+      fs8.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 path8.resolve(packageDir, normalized);
+}
+
+export { analyzeDependencies, analyzeDuplicateDependencies, analyzeMissingDependencies, analyzeTypes, analyzeUnusedDependencies, buildDependencyGraph, buildFileImportGraph, calculateHealth, calculateHealthScore, calculateLinesOfCode, calculateSize, calculateStats, checkBuilds, checkDuplicateDependencies, checkMissingReadmes, collectEntryPoints, countPackages, distPathToSrcPath, extractFileImports, findCircularDependencies, findReachableFiles, formatBytes, getBuildOrderForPackage, getImpactAnalysis, getReverseDependencies, listBackups, parseManifestHandlers, parseTsupEntries, removeDeadFiles, resolveRelativeImport, restoreFromBackup, runTests, scanDeadFiles, scoreToGrade, topologicalSort };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map