@kb-labs/quality-core 2.93.0 → 2.96.0

package/dist/index.js

@@ -1,10 +1,12 @@
-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 fs8, { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import path9, { join, dirname } from 'path';
+import { stat, readFile } from 'fs/promises';
+import { exec, execSync, execFile } from 'child_process';
+import globby2 from 'globby';
+import { defaultQualityConfig, DIMENSION_WEIGHTS, MAX_SNAPSHOTS_DEFAULT, SNAPSHOT_DIR, SNAPSHOT_FILE, HEALTH_GRADES } from '@kb-labs/quality-contracts';
 import { promisify } from 'util';
 import ts from 'typescript';
+import { randomUUID } from 'crypto';
 
 // src/graph/dependency-graph.ts
 function buildDependencyGraph(rootDir) {
@@ -18,8 +20,8 @@ function buildDependencyGraph(rootDir) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -28,7 +30,7 @@ function buildDependencyGraph(rootDir) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path9.join(packagesDir, pkgDir.name, "package.json");
       if (fs8.existsSync(packageJsonPath)) {
         const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
         const packageName = pkgJson.name;
@@ -42,8 +44,8 @@ function buildDependencyGraph(rootDir) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -52,7 +54,7 @@ function buildDependencyGraph(rootDir) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path9.join(packagesDir, pkgDir.name, "package.json");
       if (fs8.existsSync(packageJsonPath)) {
         const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
         const packageName = pkgJson.name;
@@ -80,7 +82,7 @@ function buildDependencyGraph(rootDir) {
         nodes.set(packageName, {
           name: packageName,
           path: packageJsonPath,
-          dir: path8.dirname(packageJsonPath),
+          dir: path9.dirname(packageJsonPath),
           deps,
           devDeps,
           dependents: /* @__PURE__ */ new Set()
@@ -158,10 +160,10 @@ function findCircularDependencies(graph, subset) {
   const visited = /* @__PURE__ */ new Set();
   const recStack = /* @__PURE__ */ new Set();
   const cycles = [];
-  function dfs(node, path9) {
+  function dfs(node, path12) {
     visited.add(node);
     recStack.add(node);
-    path9.push(node);
+    path12.push(node);
     const nodeData = nodes.get(node);
     if (!nodeData) {
       return;
@@ -174,11 +176,11 @@ function findCircularDependencies(graph, subset) {
         continue;
       }
       if (!visited.has(dep)) {
-        dfs(dep, [...path9]);
+        dfs(dep, [...path12]);
       } else if (recStack.has(dep)) {
-        const cycleStart = path9.indexOf(dep);
+        const cycleStart = path12.indexOf(dep);
         if (cycleStart !== -1) {
-          const cycle = path9.slice(cycleStart);
+          const cycle = path12.slice(cycleStart);
           cycles.push([...cycle, dep]);
         }
       }
@@ -247,33 +249,54 @@ function getImpactAnalysis(graph, packageName) {
   }
   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);
+var LOC_SAMPLE_SIZE = 200;
+var FALLBACK_BYTES_PER_LINE = 45;
+async function readTextFile(f) {
+  try {
+    return await readFile(f, "utf8");
+  } catch {
+    return null;
+  }
 }
-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
+var SOURCE_PATTERNS = ["*.ts", "*.tsx", "*.js", "*.jsx", "*.go"];
+async function getSourceFiles(rootDir) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...SOURCE_PATTERNS],
+      { cwd: rootDir, maxBuffer: 64 * 1024 * 1024 },
+      (err, stdout) => {
+        if (err || !stdout) {
+          return resolve([]);
+        }
+        resolve(
+          stdout.split("\0").filter(Boolean).map((f) => path9.join(rootDir, f))
+        );
+      }
+    );
   });
-  const stats = await Promise.all(files.map((f) => stat(f).catch(() => null)));
-  return stats.reduce((sum, s) => sum + (s ? s.size : 0), 0);
+}
+async function estimateLoc(files, totalSize) {
+  if (files.length === 0) {
+    return 0;
+  }
+  const indices = /* @__PURE__ */ new Set();
+  while (indices.size < Math.min(LOC_SAMPLE_SIZE, files.length)) {
+    indices.add(Math.floor(Math.random() * files.length));
+  }
+  const sample = Array.from(indices).map((i) => files[i]).filter((f) => f !== void 0);
+  const contents = await Promise.all(sample.map(readTextFile));
+  let sampleBytes = 0;
+  let sampleLines = 0;
+  for (const c of contents) {
+    if (!c) {
+      continue;
+    }
+    sampleBytes += Buffer.byteLength(c, "utf-8");
+    sampleLines += c.split("\n").length;
+  }
+  const bytesPerLine = sampleLines > 0 ? sampleBytes / sampleLines : FALLBACK_BYTES_PER_LINE;
+  return Math.round(totalSize / bytesPerLine);
 }
 function formatBytes(bytes) {
   if (bytes === 0) {
@@ -286,7 +309,7 @@ function formatBytes(bytes) {
   return `${value.toFixed(2)} ${units[i]}`;
 }
 async function countPackages(rootDir) {
-  const packageJsonFiles = await globby3("**/package.json", {
+  const packageJsonFiles = await globby2("**/package.json", {
     cwd: rootDir,
     ignore: ["**/node_modules/**", "**/.git/**", "**/.kb/**"],
     absolute: false,
@@ -295,17 +318,13 @@ async function countPackages(rootDir) {
   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)
+  const [files, packages] = await Promise.all([
+    getSourceFiles(rootDir),
+    countPackages(rootDir)
   ]);
+  const fileStats = await Promise.all(files.map((f) => stat(f).catch(() => null)));
+  const size = fileStats.reduce((sum, s) => sum + (s ? s.size : 0), 0);
+  const loc = await estimateLoc(files, size);
   return {
     packages,
     loc,
@@ -313,129 +332,114 @@ async function calculateStats(rootDir) {
     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 calculateLinesOfCode(rootDir) {
+  const files = await getSourceFiles(rootDir);
+  const fileStats = await Promise.all(files.map((f) => stat(f).catch(() => null)));
+  const size = fileStats.reduce((sum, s) => sum + (s ? s.size : 0), 0);
+  return estimateLoc(files, size);
 }
-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);
+async function calculateSize(rootDir) {
+  const files = await getSourceFiles(rootDir);
+  const fileStats = await Promise.all(files.map((f) => stat(f).catch(() => null)));
+  return fileStats.reduce((sum, s) => sum + (s ? s.size : 0), 0);
 }
-function scoreToGrade(score) {
-  if (score >= 90) {
-    return "A";
-  }
-  if (score >= 80) {
-    return "B";
-  }
-  if (score >= 70) {
-    return "C";
-  }
-  if (score >= 60) {
-    return "D";
+function gradeFromScore(score) {
+  for (const [g, { min }] of Object.entries(HEALTH_GRADES)) {
+    if (score >= min) {
+      return g;
+    }
   }
   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
+function clamp(n) {
+  return Math.max(0, Math.min(100, Math.round(n)));
+}
+function scoreArchitecture(layering, coupling, thresholds) {
+  const details = [];
+  const layeringPenalty = Math.min(layering.totalViolations * 5, 60);
+  if (layering.totalViolations > 0) {
+    details.push(`${layering.totalViolations} layering violation(s) in ${layering.affectedPackages.length} package(s)`);
+  }
+  const highInstability = coupling.packages.filter((p) => p.instability > thresholds.instability);
+  const couplingPenalty = Math.min(highInstability.length * 3, 30);
+  if (highInstability.length > 0) {
+    details.push(`${highInstability.length} package(s) with instability > ${thresholds.instability}`);
+  }
+  const score = clamp(100 - layeringPenalty - couplingPenalty);
+  return { score, grade: gradeFromScore(score), details };
+}
+function scoreTypeScript(types) {
+  const details = [];
+  const totalAny = types.packages.reduce((s, p) => s + p.anyCount, 0);
+  const anyPenalty = Math.min(totalAny * 0.5, 50);
+  if (totalAny > 0) {
+    details.push(`${totalAny} \`any\` usage(s)`);
+  }
+  const totalIgnore = types.packages.reduce((s, p) => s + p.tsIgnoreCount, 0);
+  const ignorePenalty = Math.min(totalIgnore * 2, 30);
+  if (totalIgnore > 0) {
+    details.push(`${totalIgnore} @ts-ignore(s)`);
+  }
+  const errorPenalty = Math.min(types.totalErrors * 3, 20);
+  if (types.totalErrors > 0) {
+    details.push(`${types.totalErrors} type error(s)`);
+  }
+  const score = clamp(100 - anyPenalty - ignorePenalty - errorPenalty);
+  return { score, grade: gradeFromScore(score), details };
+}
+function scoreDeadCode(knip) {
+  const details = [];
+  const filePenalty = Math.min(knip.unusedFiles.length * 2, 50);
+  if (knip.unusedFiles.length > 0) {
+    details.push(`${knip.unusedFiles.length} unused file(s)`);
+  }
+  const exportPenalty = Math.min(knip.unusedExports.length * 0.5, 30);
+  if (knip.unusedExports.length > 0) {
+    details.push(`${knip.unusedExports.length} unused export(s)`);
+  }
+  const score = clamp(100 - filePenalty - exportPenalty);
+  return { score, grade: gradeFromScore(score), details };
+}
+function scoreDepHygiene(knip) {
+  const details = [];
+  const unusedPenalty = Math.min(knip.unusedDependencies.length * 5, 50);
+  if (knip.unusedDependencies.length > 0) {
+    details.push(`${knip.unusedDependencies.length} unused dep(s)`);
+  }
+  const unlistedPenalty = Math.min(knip.unlistedDependencies.length * 10, 40);
+  if (knip.unlistedDependencies.length > 0) {
+    details.push(`${knip.unlistedDependencies.length} unlisted dep(s)`);
+  }
+  const score = clamp(100 - unusedPenalty - unlistedPenalty);
+  return { score, grade: gradeFromScore(score), details };
+}
+function scoreTestCoverage(avgCoverage) {
+  if (avgCoverage === null) {
+    return { score: 100, grade: "A", details: ["no coverage data \u2014 skipped"] };
+  }
+  const score = clamp(avgCoverage);
+  const details = avgCoverage < 80 ? [`avg coverage ${avgCoverage.toFixed(1)}%`] : [];
+  return { score, grade: gradeFromScore(score), details };
+}
+function calculateHealth(input) {
+  const { layering, coupling, types, knip, avgTestCoverage, thresholds } = input;
+  const dimensions = {
+    architecture: scoreArchitecture(layering, coupling, thresholds),
+    typescript: scoreTypeScript(types),
+    deadCode: scoreDeadCode(knip),
+    depHygiene: scoreDepHygiene(knip),
+    testCoverage: scoreTestCoverage(avgTestCoverage)
   };
+  const score = clamp(
+    Object.entries(DIMENSION_WEIGHTS).reduce(
+      (sum, [key, weight]) => sum + dimensions[key].score * weight,
+      0
+    )
+  );
+  return { score, grade: gradeFromScore(score), dimensions };
 }
 async function analyzeDuplicateDependencies(rootDir) {
-  const packageJsonFiles = await globby3("**/package.json", {
+  const packageJsonFiles = await globby2("**/package.json", {
     cwd: rootDir,
     ignore: ["**/node_modules/**", "**/.git/**"],
     absolute: true
@@ -490,7 +494,7 @@ async function analyzeDuplicateDependencies(rootDir) {
   return duplicates;
 }
 async function analyzeUnusedDependencies(rootDir) {
-  const packageJsonFiles = await globby3("**/package.json", {
+  const packageJsonFiles = await globby2("**/package.json", {
     cwd: rootDir,
     ignore: ["**/node_modules/**", "**/.git/**"],
     absolute: true
@@ -506,7 +510,7 @@ async function analyzeUnusedDependencies(rootDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      const sourceFiles = await globby3("src/**/*.{ts,tsx,js,jsx}", {
+      const sourceFiles = await globby2("src/**/*.{ts,tsx,js,jsx}", {
         cwd: pkgDir,
         absolute: true,
         ignore: ["**/*.test.*", "**/*.spec.*"]
@@ -543,7 +547,7 @@ async function analyzeUnusedDependencies(rootDir) {
   return unused;
 }
 async function analyzeMissingDependencies(rootDir) {
-  const packageJsonFiles = await globby3("**/package.json", {
+  const packageJsonFiles = await globby2("**/package.json", {
     cwd: rootDir,
     ignore: ["**/node_modules/**", "**/.git/**"],
     absolute: true
@@ -573,7 +577,7 @@ async function analyzeMissingDependencies(rootDir) {
         ...Object.keys(pkg.dependencies || {}),
         ...Object.keys(pkg.devDependencies || {})
       ]);
-      const sourceFiles = await globby3("src/**/*.{ts,tsx,js,jsx}", {
+      const sourceFiles = await globby2("src/**/*.{ts,tsx,js,jsx}", {
         cwd: pkgDir,
         absolute: true
       });
@@ -636,8 +640,8 @@ function findPackagesWithBuildScript(rootDir, filter) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -646,7 +650,7 @@ function findPackagesWithBuildScript(rootDir, filter) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path9.join(packagesDir, pkgDir.name, "package.json");
       if (fs8.existsSync(packageJsonPath)) {
         const pkgJson = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
         if (!pkgJson.scripts?.build) {
@@ -662,8 +666,8 @@ function findPackagesWithBuildScript(rootDir, filter) {
   return packages;
 }
 function isDistStale(packageDir) {
-  const distFile = path8.join(packageDir, "dist/index.js");
-  const srcDir = path8.join(packageDir, "src");
+  const distFile = path9.join(packageDir, "dist/index.js");
+  const srcDir = path9.join(packageDir, "src");
   if (!fs8.existsSync(distFile)) {
     return { stale: false };
   }
@@ -675,7 +679,7 @@ function isDistStale(packageDir) {
   function walkDir(dir) {
     const entries = fs8.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
+      const fullPath = path9.join(dir, entry.name);
       if (entry.isDirectory()) {
         walkDir(fullPath);
       } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
@@ -725,7 +729,7 @@ async function checkBuilds(rootDir, options = {}) {
   for (const pkgPath of packagePaths) {
     const pkgJson = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     const packageName = pkgJson.name;
-    const packageDir = path8.dirname(pkgPath);
+    const packageDir = path9.dirname(pkgPath);
     const staleCheck = isDistStale(packageDir);
     if (staleCheck.stale) {
       result.staleBuilds.push({
@@ -759,8 +763,8 @@ function findPackagesWithTsConfig(rootDir, filter) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -769,8 +773,8 @@ function findPackagesWithTsConfig(rootDir, filter) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
-      const tsconfigPath = path8.join(packagesDir, pkgDir.name, "tsconfig.json");
+      const packageJsonPath = path9.join(packagesDir, pkgDir.name, "package.json");
+      const tsconfigPath = path9.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)) {
@@ -778,7 +782,7 @@ function findPackagesWithTsConfig(rootDir, filter) {
         }
         packages.push({
           name: pkgJson.name,
-          dir: path8.dirname(packageJsonPath),
+          dir: path9.dirname(packageJsonPath),
           tsconfigPath
         });
       }
@@ -804,7 +808,7 @@ function createProgram(packageDir, tsconfigPath) {
       rootNames: parsedConfig.fileNames,
       options: parsedConfig.options
     });
-  } catch (err) {
+  } catch {
     return null;
   }
 }
@@ -910,8 +914,8 @@ function findPackagesWithTests(rootDir, filter) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -920,7 +924,7 @@ function findPackagesWithTests(rootDir, filter) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path9.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)) {
@@ -928,7 +932,7 @@ function findPackagesWithTests(rootDir, filter) {
         }
         packages.push({
           name: pkgJson.name,
-          dir: path8.dirname(packageJsonPath),
+          dir: path9.dirname(packageJsonPath),
           hasTestScript: !!pkgJson.scripts?.test
         });
       }
@@ -985,7 +989,7 @@ function parseTestOutput(output) {
   return {};
 }
 function readCoverage(packageDir) {
-  const coveragePath = path8.join(packageDir, "coverage", "coverage-summary.json");
+  const coveragePath = path9.join(packageDir, "coverage", "coverage-summary.json");
   if (!fs8.existsSync(coveragePath)) {
     return null;
   }
@@ -1122,7 +1126,7 @@ async function collectEntryPoints(packageDir, packageJson) {
   await collectTestFiles(packageDir, aliveByConvention);
   collectConfigFiles(packageDir, aliveByConvention);
   if (entryFiles.size === 0) {
-    const defaultEntry = path8.join(packageDir, "src", "index.ts");
+    const defaultEntry = path9.join(packageDir, "src", "index.ts");
     if (fs8.existsSync(defaultEntry)) {
       entryFiles.add(defaultEntry);
       warnings.push("No entry points found, using src/index.ts as default");
@@ -1136,11 +1140,11 @@ function distPathToSrcPath(distPath, packageDir) {
     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);
+  const absolute = path9.resolve(packageDir, normalized);
   if (fs8.existsSync(absolute)) {
     return absolute;
   }
-  const indexPath = path8.join(absolute.replace(/\.ts$/, ""), "index.ts");
+  const indexPath = path9.join(absolute.replace(/\.ts$/, ""), "index.ts");
   if (fs8.existsSync(indexPath)) {
     return indexPath;
   }
@@ -1219,7 +1223,7 @@ async function collectTsupEntries(packageDir, entryFiles, warnings) {
   ];
   let foundAny = false;
   for (const configName of tsupConfigs) {
-    const configPath = path8.join(packageDir, configName);
+    const configPath = path9.join(packageDir, configName);
     if (!fs8.existsSync(configPath)) {
       continue;
     }
@@ -1229,7 +1233,7 @@ async function collectTsupEntries(packageDir, entryFiles, warnings) {
       const entries = parseTsupEntries(content);
       for (const entry of entries) {
         if (entry.includes("*") || entry.includes("{")) {
-          const expanded = await globby3(entry, {
+          const expanded = await globby2(entry, {
             cwd: packageDir,
             absolute: true
           });
@@ -1237,7 +1241,7 @@ async function collectTsupEntries(packageDir, entryFiles, warnings) {
             entryFiles.add(file);
           }
         } else {
-          const absolute = path8.resolve(packageDir, entry);
+          const absolute = path9.resolve(packageDir, entry);
           if (fs8.existsSync(absolute)) {
             entryFiles.add(absolute);
           }
@@ -1277,7 +1281,7 @@ function parseTsupEntries(content) {
   return entries;
 }
 function collectManifestHandlers(packageDir, entryFiles, warnings) {
-  const manifestPath = path8.join(packageDir, "src", "manifest.ts");
+  const manifestPath = path9.join(packageDir, "src", "manifest.ts");
   if (!fs8.existsSync(manifestPath)) {
     return;
   }
@@ -1287,7 +1291,7 @@ function collectManifestHandlers(packageDir, entryFiles, warnings) {
     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);
+      const absolute = path9.resolve(packageDir, srcRelative);
       if (fs8.existsSync(absolute)) {
         entryFiles.add(absolute);
       }
@@ -1316,11 +1320,11 @@ function parseManifestHandlers(content) {
   return handlers;
 }
 async function collectDynamicImportTargets(packageDir, entryFiles, _warnings) {
-  const srcDir = path8.join(packageDir, "src");
+  const srcDir = path9.join(packageDir, "src");
   if (!fs8.existsSync(srcDir)) {
     return;
   }
-  const sourceFiles = await globby3("**/*.{ts,tsx}", {
+  const sourceFiles = await globby2("**/*.{ts,tsx}", {
     cwd: srcDir,
     absolute: true,
     ignore: ["**/*.test.ts", "**/*.spec.ts", "**/__tests__/**"]
@@ -1345,11 +1349,11 @@ async function collectDynamicImportTargets(packageDir, entryFiles, _warnings) {
   }
 }
 async function collectTestFiles(packageDir, aliveByConvention) {
-  const srcDir = path8.join(packageDir, "src");
+  const srcDir = path9.join(packageDir, "src");
   if (!fs8.existsSync(srcDir)) {
     return;
   }
-  const testFiles = await globby3(
+  const testFiles = await globby2(
     ["**/*.test.ts", "**/*.test.tsx", "**/*.spec.ts", "**/*.spec.tsx", "**/__tests__/**/*.ts"],
     { cwd: srcDir, absolute: true }
   );
@@ -1359,15 +1363,15 @@ async function collectTestFiles(packageDir, aliveByConvention) {
 }
 function collectConfigFiles(packageDir, aliveByConvention) {
   for (const pattern of CONFIG_FILE_PATTERNS) {
-    const configPath = path8.join(packageDir, pattern);
+    const configPath = path9.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 dir = path9.dirname(fromFile);
+  const base = path9.resolve(dir, importPath);
   const tsPath = base.replace(/\.js$/, ".ts");
   if (fs8.existsSync(tsPath)) {
     return tsPath;
@@ -1381,8 +1385,8 @@ function resolveFilePath(importPath, fromFile) {
   if (fs8.existsSync(base + ".tsx")) {
     return base + ".tsx";
   }
-  if (fs8.existsSync(path8.join(base, "index.ts"))) {
-    return path8.join(base, "index.ts");
+  if (fs8.existsSync(path9.join(base, "index.ts"))) {
+    return path9.join(base, "index.ts");
   }
   return null;
 }
@@ -1415,8 +1419,8 @@ function isRelativeImport(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
 function resolveRelativeImport(specifier, sourceFile) {
-  const dir = path8.dirname(sourceFile);
-  const basePath = path8.resolve(dir, specifier);
+  const dir = path9.dirname(sourceFile);
+  const basePath = path9.resolve(dir, specifier);
   if (specifier.endsWith(".js")) {
     const tsPath = basePath.slice(0, -3) + ".ts";
     if (fs8.existsSync(tsPath)) {
@@ -1438,14 +1442,14 @@ function resolveRelativeImport(specifier, sourceFile) {
   }
   if (fs8.existsSync(basePath) && fs8.statSync(basePath).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const indexPath = path8.join(basePath, "index" + ext);
+      const indexPath = path9.join(basePath, "index" + ext);
       if (fs8.existsSync(indexPath)) {
         return indexPath;
       }
     }
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexPath = path8.join(basePath, "index" + ext);
+    const indexPath = path9.join(basePath, "index" + ext);
     if (fs8.existsSync(indexPath)) {
       return indexPath;
     }
@@ -1530,8 +1534,8 @@ function findPackagesInMonorepo(rootDir, filter) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path8.join(rootDir, entry.name);
-    const packagesDir = path8.join(repoPath, "packages");
+    const repoPath = path9.join(rootDir, entry.name);
+    const packagesDir = path9.join(repoPath, "packages");
     if (!fs8.existsSync(packagesDir)) {
       continue;
     }
@@ -1540,15 +1544,15 @@ function findPackagesInMonorepo(rootDir, filter) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path8.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path9.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");
+        const packageDir = path9.join(packagesDir, pkgDir.name);
+        const srcDir = path9.join(packageDir, "src");
         if (!fs8.existsSync(srcDir)) {
           continue;
         }
@@ -1564,8 +1568,8 @@ function findPackagesInMonorepo(rootDir, filter) {
 }
 async function analyzePackage(pkg) {
   const { packageDir, packageJson, packageName } = pkg;
-  const srcDir = path8.join(packageDir, "src");
-  const allSourceFiles = await globby3("**/*.{ts,tsx}", {
+  const srcDir = path9.join(packageDir, "src");
+  const allSourceFiles = await globby2("**/*.{ts,tsx}", {
     cwd: srcDir,
     absolute: true,
     ignore: ["**/*.d.ts"]
@@ -1586,7 +1590,7 @@ async function analyzePackage(pkg) {
       totalFiles: allSourceFiles.length,
       aliveFiles: allSourceFiles.length,
       deadFiles: [],
-      entryPoints: [...entryFiles].map((f) => path8.relative(packageDir, f)),
+      entryPoints: [...entryFiles].map((f) => path9.relative(packageDir, f)),
       graphEdgeCount: 0,
       warnings: [...warnings, "FAIL-OPEN: All files treated as alive due to config parse errors"]
     };
@@ -1602,7 +1606,7 @@ async function analyzePackage(pkg) {
       const stats = safeFileStat(file);
       deadFiles.push({
         absolutePath: file,
-        relativePath: path8.relative(packageDir, file),
+        relativePath: path9.relative(packageDir, file),
         packageName,
         packageDir,
         sizeBytes: stats?.size ?? 0
@@ -1616,7 +1620,7 @@ async function analyzePackage(pkg) {
     totalFiles: allSourceFiles.length,
     aliveFiles: allSourceFiles.length - deadFiles.length,
     deadFiles,
-    entryPoints: [...entryFiles].map((f) => path8.relative(packageDir, f)),
+    entryPoints: [...entryFiles].map((f) => path9.relative(packageDir, f)),
     graphEdgeCount,
     warnings
   };
@@ -1650,14 +1654,14 @@ function findPotentialEmptyDirs(results, _rootDir) {
     }
     const deadByDir = /* @__PURE__ */ new Map();
     for (const deadFile of pkg.deadFiles) {
-      const dir = path8.dirname(deadFile.absolutePath);
+      const dir = path9.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));
+          emptyDirs.push(path9.relative(pkg.packageDir, dir));
         }
       } catch {
       }
@@ -1672,11 +1676,65 @@ function safeFileStat(filePath) {
     return null;
   }
 }
+
+// src/dead-code/knip-runner.ts
+async function runKnip(opts) {
+  const { shell, rootDir } = opts;
+  const result = await shell.exec("pnpm", ["knip", "--reporter", "json"], { cwd: rootDir }).catch(() => null);
+  if (!result) {
+    return emptyReport();
+  }
+  const raw = result.stdout.trim();
+  if (!raw || raw === "{}" || raw === "[]") {
+    return emptyReport();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return emptyReport();
+  }
+  return parseKnipOutput(parsed, rootDir);
+}
+function parseKnipOutput(out, rootDir) {
+  const unusedFiles = (out.files ?? []).map(
+    (f) => f.startsWith("/") ? f : `${rootDir}/${f}`
+  );
+  const unusedExports = (out.exports ?? []).flatMap(
+    (entry) => (entry.exports ?? []).map((exp) => ({
+      file: entry.file,
+      symbol: exp.symbol
+    }))
+  );
+  const unusedDependencies = (out.dependencies ?? []).flatMap(
+    (dep) => (dep.packages ?? [rootDir]).map((workspace) => ({
+      package: dep.name,
+      workspace
+    }))
+  );
+  const unlistedDependencies = (out.unlisted ?? []).flatMap(
+    (dep) => (dep.packages ?? [rootDir]).map((workspace) => ({
+      package: dep.name,
+      workspace
+    }))
+  );
+  const totalIssues = unusedFiles.length + unusedExports.length + unusedDependencies.length + unlistedDependencies.length;
+  return { unusedFiles, unusedExports, unusedDependencies, unlistedDependencies, totalIssues };
+}
+function emptyReport() {
+  return {
+    unusedFiles: [],
+    unusedExports: [],
+    unusedDependencies: [],
+    unlistedDependencies: [],
+    totalIssues: 0
+  };
+}
 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 backupPath = path9.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 = [];
@@ -1711,7 +1769,7 @@ async function removeDeadFiles(rootDir, scanResult, options) {
     gitBranch,
     removedFiles: allDeadFiles.map((f) => ({
       originalPath: f.absolutePath,
-      backupPath: path8.relative(rootDir, f.absolutePath),
+      backupPath: path9.relative(rootDir, f.absolutePath),
       packageName: f.packageName,
       sizeBytes: f.sizeBytes
     })),
@@ -1731,45 +1789,45 @@ async function removeDeadFiles(rootDir, scanResult, options) {
       manifest
     };
   }
-  const filesDir = path8.join(backupPath, "files");
+  const filesDir = path9.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);
+    const relPath = path9.relative(rootDir, deadFile.absolutePath);
+    const destPath = path9.join(filesDir, relPath);
+    const destDir = path9.dirname(destPath);
     fs8.mkdirSync(destDir, { recursive: true });
     fs8.copyFileSync(deadFile.absolutePath, destPath);
   }
   fs8.writeFileSync(
-    path8.join(backupPath, "manifest.json"),
+    path9.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)));
+  const deadFileDirs = new Set(allDeadFiles.map((f) => path9.dirname(f.absolutePath)));
   for (const dir of deadFileDirs) {
     removeEmptyDirsUpward(dir, rootDir, removedDirs);
   }
-  manifest.removedEmptyDirs = removedDirs.map((d) => path8.relative(rootDir, d));
+  manifest.removedEmptyDirs = removedDirs.map((d) => path9.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 pkgJsonPath = path9.join(pkg.packageDir, "package.json");
     const cleaned = cleanPackageJsonExports(pkgJsonPath, deletedPaths, pkg.packageDir);
     if (cleaned.length > 0) {
       manifest.cleanedExports.push({
-        packageJsonPath: path8.relative(rootDir, pkgJsonPath),
+        packageJsonPath: path9.relative(rootDir, pkgJsonPath),
         removedExportKeys: cleaned
       });
       exportsCleanedUp += cleaned.length;
     }
   }
   fs8.writeFileSync(
-    path8.join(backupPath, "manifest.json"),
+    path9.join(backupPath, "manifest.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
   return {
@@ -1783,8 +1841,8 @@ async function removeDeadFiles(rootDir, scanResult, options) {
   };
 }
 async function restoreFromBackup(rootDir, backupId) {
-  const backupPath = path8.join(rootDir, BACKUP_DIR, backupId);
-  const manifestPath = path8.join(backupPath, "manifest.json");
+  const backupPath = path9.join(rootDir, BACKUP_DIR, backupId);
+  const manifestPath = path9.join(backupPath, "manifest.json");
   if (!fs8.existsSync(manifestPath)) {
     throw new Error(`Backup not found: ${backupId}`);
   }
@@ -1793,18 +1851,18 @@ async function restoreFromBackup(rootDir, backupId) {
   );
   let restoredFiles = 0;
   for (const entry of manifest.removedFiles) {
-    const backupFilePath = path8.join(backupPath, "files", entry.backupPath);
+    const backupFilePath = path9.join(backupPath, "files", entry.backupPath);
     if (!fs8.existsSync(backupFilePath)) {
       continue;
     }
-    const parentDir = path8.dirname(entry.originalPath);
+    const parentDir = path9.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);
+    const pkgJsonPath = path9.resolve(rootDir, exportEntry.packageJsonPath);
     if (!fs8.existsSync(pkgJsonPath)) {
       continue;
     }
@@ -1813,7 +1871,7 @@ async function restoreFromBackup(rootDir, backupId) {
   return { restoredFiles, restoredExports };
 }
 function listBackups(rootDir) {
-  const backupDir = path8.join(rootDir, BACKUP_DIR);
+  const backupDir = path9.join(rootDir, BACKUP_DIR);
   if (!fs8.existsSync(backupDir)) {
     return [];
   }
@@ -1823,7 +1881,7 @@ function listBackups(rootDir) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const manifestPath = path8.join(backupDir, entry.name, "manifest.json");
+    const manifestPath = path9.join(backupDir, entry.name, "manifest.json");
     if (!fs8.existsSync(manifestPath)) {
       continue;
     }
@@ -1855,7 +1913,7 @@ function removeEmptyDirsUpward(dir, rootBoundary, removed) {
       }
       fs8.rmdirSync(current);
       removed.push(current);
-      current = path8.dirname(current);
+      current = path9.dirname(current);
     } catch {
       break;
     }
@@ -1915,9 +1973,324 @@ function distToSrcForExportCheck(distPath, packageDir) {
   }
   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);
+  return path9.resolve(packageDir, normalized);
+}
+function resolveLayer(pkgDir, rootDir, layerMap = defaultQualityConfig.layers) {
+  const rel = path9.relative(rootDir, pkgDir).replace(/\\/g, "/");
+  for (const [prefix, layer] of Object.entries(layerMap)) {
+    if (rel.startsWith(prefix)) {
+      return layer;
+    }
+  }
+  return -1;
+}
+function scanWorkspace(rootDir, layerMap = defaultQualityConfig.layers) {
+  const packages = [];
+  if (!fs8.existsSync(rootDir)) {
+    return packages;
+  }
+  const topDirs = ["core", "sdk", "shared", "cli", "adapters", "studio", "infra"];
+  const pluginDirs = ["plugins"];
+  const collect = (dir, maxDepth) => {
+    if (!fs8.existsSync(dir)) {
+      return;
+    }
+    const pkgJson = path9.join(dir, "package.json");
+    if (fs8.existsSync(pkgJson)) {
+      tryAddPackage(pkgJson);
+      return;
+    }
+    if (maxDepth <= 0) {
+      return;
+    }
+    for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === "node_modules" || entry.name.startsWith(".")) {
+        continue;
+      }
+      collect(path9.join(dir, entry.name), maxDepth - 1);
+    }
+  };
+  const tryAddPackage = (pkgJsonPath) => {
+    try {
+      const raw = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
+      if (!raw.name) {
+        return;
+      }
+      const dir = path9.dirname(pkgJsonPath);
+      packages.push({
+        name: raw.name,
+        dir,
+        packageJsonPath: pkgJsonPath,
+        layer: resolveLayer(dir, rootDir, layerMap),
+        deps: Object.keys(raw.dependencies ?? {}),
+        devDeps: Object.keys(raw.devDependencies ?? {})
+      });
+    } catch {
+    }
+  };
+  for (const top of topDirs) {
+    collect(path9.join(rootDir, top), 1);
+  }
+  for (const top of pluginDirs) {
+    collect(path9.join(rootDir, top), 2);
+  }
+  return packages;
+}
+function buildPackageMap(packages) {
+  return new Map(packages.map((p) => [p.name, p]));
+}
+function extractImportSpecifiers(filePath) {
+  let source;
+  try {
+    source = fs8.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+  const specifiers = [];
+  const visit = (node) => {
+    if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+      specifiers.push(node.moduleSpecifier.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  return specifiers;
+}
+function resolveToPackageName(specifier, workspaceNames) {
+  if (specifier.startsWith(".") || specifier.startsWith("node:")) {
+    return null;
+  }
+  const scoped = specifier.match(/^(@[^/]+\/[^/]+)/);
+  if (scoped) {
+    const pkg = scoped[1];
+    return workspaceNames.has(pkg) ? pkg : null;
+  }
+  const name = specifier.split("/")[0];
+  if (name) {
+    return workspaceNames.has(name) ? name : null;
+  }
+  return null;
 }
+async function analyzeLayering(opts) {
+  const { rootDir, layerMap } = opts;
+  const packages = scanWorkspace(rootDir, layerMap);
+  const packageMap = buildPackageMap(packages);
+  const workspaceNames = new Set(packageMap.keys());
+  const violations = [];
+  await Promise.all(
+    packages.filter((pkg) => pkg.layer >= 0).map(async (pkg) => {
+      const srcDir = path9.join(pkg.dir, "src");
+      if (!fs8.existsSync(srcDir)) {
+        return;
+      }
+      const files = await globby2("**/*.{ts,tsx}", {
+        cwd: srcDir,
+        ignore: ["**/*.test.ts", "**/*.spec.ts", "**/__tests__/**", "**/node_modules/**"],
+        absolute: true,
+        deep: 10
+      });
+      for (const file of files) {
+        const specifiers = extractImportSpecifiers(file);
+        for (const spec of specifiers) {
+          const importedPkg = resolveToPackageName(spec, workspaceNames);
+          if (!importedPkg) {
+            continue;
+          }
+          const importedLayer = packageMap.get(importedPkg)?.layer ?? resolveLayer(importedPkg, rootDir, layerMap);
+          if (importedLayer < 0) {
+            continue;
+          }
+          if (importedLayer > pkg.layer) {
+            violations.push({
+              file,
+              fromPackage: pkg.name,
+              fromLayer: pkg.layer,
+              toPackage: importedPkg,
+              toLayer: importedLayer,
+              importSpecifier: spec
+            });
+          }
+        }
+      }
+    })
+  );
+  const affectedPackages = [...new Set(violations.map((v) => v.fromPackage))];
+  return {
+    violations,
+    totalViolations: violations.length,
+    affectedPackages,
+    layerMap: layerMap ?? defaultQualityConfig.layers
+  };
+}
+
+// src/architecture/coupling.ts
+function analyzeCoupling(opts) {
+  const { rootDir, layerMap, topN = 5 } = opts;
+  const packages = scanWorkspace(rootDir, layerMap);
+  const allNames = new Set(packages.map((p) => p.name));
+  const afferentCount = new Map(packages.map((p) => [p.name, 0]));
+  for (const pkg of packages) {
+    const workspaceDeps = [...pkg.deps, ...pkg.devDeps].filter((d) => allNames.has(d));
+    for (const dep of workspaceDeps) {
+      afferentCount.set(dep, (afferentCount.get(dep) ?? 0) + 1);
+    }
+  }
+  const result = packages.map((pkg) => {
+    const ce = [...pkg.deps, ...pkg.devDeps].filter((d) => allNames.has(d)).length;
+    const ca = afferentCount.get(pkg.name) ?? 0;
+    const total = ca + ce;
+    const instability = total === 0 ? 0 : ce / total;
+    return {
+      name: pkg.name,
+      afferent: ca,
+      efferent: ce,
+      instability: Math.round(instability * 100) / 100
+    };
+  });
+  const avgInstability = result.length === 0 ? 0 : Math.round(result.reduce((s, p) => s + p.instability, 0) / result.length * 100) / 100;
+  const sorted = [...result].sort((a, b) => b.instability - a.instability);
+  const mostUnstable = sorted.slice(0, topN).map((p) => ({ ...p }));
+  const mostCoupled = [...result].sort((a, b) => b.afferent + b.efferent - (a.afferent + a.efferent)).slice(0, topN).map((p) => ({ ...p }));
+  return { packages: result, avgInstability, mostUnstable, mostCoupled };
+}
+
+// src/architecture/build-order.ts
+function analyzeBuildOrder(opts) {
+  const { rootDir, layerMap, filterPackage } = opts;
+  const packages = scanWorkspace(rootDir, layerMap);
+  const allNames = new Set(packages.map((p) => p.name));
+  const deps = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const wsDeps = new Set(pkg.deps.filter((d) => allNames.has(d)));
+    deps.set(pkg.name, wsDeps);
+  }
+  let names;
+  if (filterPackage && allNames.has(filterPackage)) {
+    const visited = /* @__PURE__ */ new Set();
+    const visit = (n) => {
+      if (visited.has(n)) {
+        return;
+      }
+      visited.add(n);
+      for (const d of deps.get(n) ?? []) {
+        visit(d);
+      }
+    };
+    visit(filterPackage);
+    names = [...visited];
+  } else {
+    names = packages.map((p) => p.name);
+  }
+  const nameSet = new Set(names);
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const n of names) {
+    const count = [...deps.get(n) ?? []].filter((d) => nameSet.has(d)).length;
+    inDegree.set(n, count);
+  }
+  const layers = [];
+  const sorted = [];
+  const enqueued = /* @__PURE__ */ new Set();
+  let queue = names.filter((n) => (inDegree.get(n) ?? 0) === 0);
+  for (const n of queue) {
+    enqueued.add(n);
+  }
+  while (queue.length > 0) {
+    layers.push([...queue]);
+    sorted.push(...queue);
+    const next = [];
+    for (const d of queue) {
+      for (const n of names) {
+        if (enqueued.has(n)) {
+          continue;
+        }
+        if ((deps.get(n) ?? /* @__PURE__ */ new Set()).has(d)) {
+          const deg = (inDegree.get(n) ?? 1) - 1;
+          inDegree.set(n, deg);
+          if (deg === 0) {
+            next.push(n);
+            enqueued.add(n);
+          }
+        }
+      }
+    }
+    queue = next;
+  }
+  const circular = names.filter((n) => !sorted.includes(n));
+  return {
+    layers,
+    sorted,
+    circular: circular.length > 0 ? [circular] : [],
+    packageCount: sorted.length,
+    layerCount: layers.length,
+    hasCircular: circular.length > 0
+  };
+}
+function readSnapshots(filePath) {
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeSnapshots(filePath, data) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+function computeDelta(current, previous) {
+  return {
+    score: current.score - previous.score,
+    layeringViolations: current.counters.layeringViolations - previous.counters.layeringViolations,
+    anyCount: current.counters.anyCount - previous.counters.anyCount,
+    tsIgnoreCount: current.counters.tsIgnoreCount - previous.counters.tsIgnoreCount,
+    unusedFiles: current.counters.unusedFiles - previous.counters.unusedFiles,
+    unusedDeps: current.counters.unusedDeps - previous.counters.unusedDeps,
+    avgInstability: Math.round((current.counters.avgInstability - previous.counters.avgInstability) * 100) / 100
+  };
+}
+var QualitySnapshotStore = class {
+  snapshotPath;
+  maxEntries;
+  constructor(rootDir, maxEntries = MAX_SNAPSHOTS_DEFAULT) {
+    this.snapshotPath = join(rootDir, SNAPSHOT_DIR, SNAPSHOT_FILE);
+    this.maxEntries = maxEntries;
+  }
+  load() {
+    return readSnapshots(this.snapshotPath);
+  }
+  save(input) {
+    const snap = {
+      id: randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input
+    };
+    const history = this.load();
+    history.push(snap);
+    while (history.length > this.maxEntries) {
+      history.shift();
+    }
+    writeSnapshots(this.snapshotPath, history);
+    return snap;
+  }
+  latest() {
+    const h = this.load();
+    return h.length > 0 ? h[h.length - 1] ?? null : null;
+  }
+  history() {
+    const snapshots = this.load();
+    const latest = snapshots.length > 0 ? snapshots[snapshots.length - 1] ?? null : null;
+    const previous = snapshots.length > 1 ? snapshots[snapshots.length - 2] ?? null : null;
+    const delta = latest && previous ? computeDelta(latest, previous) : null;
+    return { snapshots, delta, latest };
+  }
+};
 
-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 };
+export { QualitySnapshotStore, analyzeBuildOrder, analyzeCoupling, analyzeDependencies, analyzeDuplicateDependencies, analyzeLayering, analyzeMissingDependencies, analyzeTypes, analyzeUnusedDependencies, buildDependencyGraph, buildFileImportGraph, buildPackageMap, calculateHealth, calculateLinesOfCode, calculateSize, calculateStats, checkBuilds, collectEntryPoints, countPackages, distPathToSrcPath, extractFileImports, findCircularDependencies, findReachableFiles, formatBytes, getBuildOrderForPackage, getImpactAnalysis, getReverseDependencies, listBackups, parseManifestHandlers, parseTsupEntries, removeDeadFiles, resolveLayer, resolveRelativeImport, restoreFromBackup, runKnip, runTests, scanDeadFiles, scanWorkspace, topologicalSort };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map