@kb-labs/quality-entry 2.93.0 → 2.96.0

package/dist/cli/commands/index.js

@@ -1,12 +1,12 @@
-import { defineCommand, useLoader } from '@kb-labs/sdk';
-import { buildDependencyGraph, getBuildOrderForPackage, topologicalSort, findCircularDependencies, getReverseDependencies, getImpactAnalysis } from '@kb-labs/quality-core/graph';
-import { CACHE_KEYS } from '@kb-labs/quality-contracts';
+import { defineCommand, useConfig, validationError, useLoader } from '@kb-labs/sdk';
+import { analyzeBuildOrder, analyzeLayering, analyzeCoupling, runKnip, analyzeTypes as analyzeTypes$1, calculateHealth, QualitySnapshotStore, calculateStats } from '@kb-labs/quality-core';
+import { defaultQualityConfig, CACHE_KEYS, CACHE_TTLS } from '@kb-labs/quality-contracts';
 import { checkBuilds } from '@kb-labs/quality-core/builds';
 import { runTests } from '@kb-labs/quality-core/tests';
 import { analyzeTypes } from '@kb-labs/quality-core/types';
-import { listBackups, restoreFromBackup, scanDeadFiles, removeDeadFiles } from '@kb-labs/quality-core/dead-code';
+import { buildDependencyGraph, findCircularDependencies, getReverseDependencies, getImpactAnalysis } from '@kb-labs/quality-core/graph';
 import fs from 'fs';
-import path3 from 'path';
+import path from 'path';
 
 // src/cli/commands/build-order.ts
 var build_order_default = defineCommand({
@@ -14,106 +14,53 @@ var build_order_default = defineCommand({
   description: "Calculate build order using topological sort",
   handler: {
     async execute(ctx, input) {
-      const { ui } = ctx;
-      const flags = "flags" in input && typeof input.flags === "object" && input.flags !== null ? input.flags : input;
-      const graph = buildDependencyGraph(ctx.cwd);
-      let result;
-      if (flags.package) {
-        result = getBuildOrderForPackage(graph, flags.package);
-      } else {
-        result = topologicalSort(graph);
-      }
-      if (result.circular.length > 0) {
-        ui?.error?.(
-          `Found ${result.circular.length} circular dependencies. Build order cannot be determined.`
-        );
-        outputCircularDependencies(result.circular, ui);
-        return { exitCode: 1, result };
-      }
-      outputBuildOrder(result, flags, ui);
-      return { exitCode: 0, result };
-    }
-  }
-});
-function outputBuildOrder(result, flags, ui) {
-  if (flags.json) {
-    ui?.json?.(result);
-    return;
-  }
-  if (flags.script) {
-    ui?.write?.("#!/bin/bash");
-    ui?.write?.("# Generated build script");
-    ui?.write?.("set -e");
-    ui?.write?.("");
-    for (let i = 0; i < result.layers.length; i++) {
-      const layer = result.layers[i];
-      if (!layer) {
-        continue;
-      }
-      ui?.write?.(`# Layer ${i + 1} (${layer.length} packages)`);
-      for (const pkg of layer) {
-        ui?.write?.(`pnpm --filter "${pkg}" run build`);
+      const { flags } = input;
+      const config = await useConfig();
+      const cfg = config ?? defaultQualityConfig;
+      const cwd = ctx.cwd ?? process.cwd();
+      const result = analyzeBuildOrder({
+        rootDir: cwd,
+        layerMap: cfg.layers,
+        filterPackage: flags.package
+      });
+      if (result.hasCircular) {
+        if (flags.json) {
+          ctx.ui?.json?.({ ...result, ok: false });
+        } else {
+          ctx.ui?.error?.(`Circular dependencies detected \u2014 build order cannot be fully determined`, {
+            sections: result.circular.map((cycle, i) => ({
+              header: `Cycle ${i + 1}`,
+              items: cycle
+            }))
+          });
+        }
+        return { exitCode: 1 };
       }
-      ui?.write?.("");
-    }
-    return;
-  }
-  const sections = [];
-  if (flags.layers) {
-    const layerItems = [];
-    for (let i = 0; i < result.layers.length; i++) {
-      const layer = result.layers[i];
-      if (!layer) {
-        continue;
+      if (flags.json) {
+        ctx.ui?.json?.(result);
+        return { exitCode: 0 };
       }
-      layerItems.push(`Layer ${i + 1}: ${layer.length} packages (can build in parallel)`);
-      for (const pkg of layer) {
-        layerItems.push(`  \u2022 ${pkg}`);
+      if (flags.script) {
+        for (let i = 0; i < result.layers.length; i++) {
+          const layer = result.layers[i];
+          if (!layer) continue;
+          ctx.ui?.success?.(`# Layer ${i + 1}`, { sections: [{ header: "", items: layer.map((p) => `pnpm --filter "${p}" run build`) }] });
+        }
+        return { exitCode: 0 };
       }
-      layerItems.push("");
-    }
-    sections.push({ header: "Build Layers", items: layerItems });
-  } else {
-    const orderItems = result.sorted.map((pkg, idx) => `${idx + 1}. ${pkg}`);
-    sections.push({ header: "Build Order", items: orderItems });
-  }
-  sections.push({
-    header: "Summary",
-    items: [
-      `Total packages: ${result.sorted.length}`,
-      `Build layers: ${result.layers.length}`,
-      `Circular dependencies: ${result.circular.length}`
-    ]
-  });
-  const title = flags.package ? `\u{1F4E6} Build Order for ${flags.package}` : "\u{1F4E6} Monorepo Build Order";
-  ui?.success?.("Build order calculated successfully", {
-    title,
-    sections
-  });
-}
-function outputCircularDependencies(cycles, ui) {
-  const sections = [];
-  for (let i = 0; i < cycles.length; i++) {
-    const cycle = cycles[i];
-    if (!cycle) {
-      continue;
+      const sections = flags.layers ? result.layers.map((layer, i) => ({
+        header: `Layer ${i + 1} \u2014 ${layer.length} package(s) (parallel)`,
+        items: layer
+      })) : [{ header: "Build order", items: result.sorted.map((p, i) => `${i + 1}. ${p}`) }];
+      sections.push({
+        header: "Summary",
+        items: [`${result.packageCount} packages in ${result.layerCount} layers`]
+      });
+      ctx.ui?.success?.(flags.package ? `Build order for ${flags.package}` : "Monorepo build order", { sections });
+      return { exitCode: 0 };
     }
-    sections.push({
-      header: `Cycle ${i + 1}`,
-      items: cycle.map((pkg, idx) => {
-        if (idx === cycle.length - 1) {
-          const firstPkg = cycle[0];
-          return `  ${pkg} \u2192 ${firstPkg ?? "?"} (circular!)`;
-        }
-        return `  ${pkg} \u2192`;
-      })
-    });
   }
-  ui?.error?.("Circular dependencies detected", {
-    title: "\u26A0\uFE0F Circular Dependencies",
-    sections
-  });
-}
+});
 var check_builds_default = defineCommand({
   id: "quality:check-builds",
   description: "Check build status across monorepo",
@@ -402,6 +349,73 @@ function outputTypeAnalysis(result, flags, ui) {
     sections
   });
 }
+var check_layers_default = defineCommand({
+  id: "quality:check-layers",
+  description: "Detect layering violations (lower layer importing higher layer)",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const report = await analyzeLayering({
+        rootDir: cwd,
+        layerMap: config?.layers
+      });
+      const filtered = flags.package ? {
+        ...report,
+        violations: report.violations.filter((v) => v.fromPackage.includes(flags.package)),
+        totalViolations: report.violations.filter((v) => v.fromPackage.includes(flags.package)).length
+      } : report;
+      if (flags.json) {
+        ctx.ui?.json?.(filtered);
+        return { exitCode: filtered.totalViolations > 0 ? 1 : 0 };
+      }
+      if (filtered.totalViolations === 0) {
+        ctx.ui?.success?.("No layering violations found");
+        return { exitCode: 0 };
+      }
+      const byPackage = /* @__PURE__ */ new Map();
+      for (const v of filtered.violations) {
+        const list = byPackage.get(v.fromPackage) ?? [];
+        list.push(v);
+        byPackage.set(v.fromPackage, list);
+      }
+      const sections = [...byPackage.entries()].map(([pkg, vs]) => ({
+        header: `${pkg} (Layer ${vs[0]?.fromLayer})`,
+        items: vs.map((v) => `\u2192 ${v.toPackage} (Layer ${v.toLayer})  ${v.importSpecifier}`)
+      }));
+      ctx.ui?.error?.(`${filtered.totalViolations} layering violation(s) in ${filtered.affectedPackages.length} package(s)`, { sections });
+      return { exitCode: 1 };
+    }
+  }
+});
+var coupling_default = defineCommand({
+  id: "quality:coupling",
+  description: "Show coupling metrics per package (afferent/efferent/instability)",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const report = analyzeCoupling({ rootDir: cwd, layerMap: config?.layers, topN: flags.top });
+      if (flags.json) {
+        ctx.ui?.json?.(report);
+        return { exitCode: 0 };
+      }
+      const sorted = flags.sort === "coupled" ? [...report.packages].sort((a, b) => b.afferent + b.efferent - (a.afferent + a.efferent)) : [...report.packages].sort((a, b) => b.instability - a.instability);
+      const top = sorted.slice(0, flags.top ?? 10);
+      const threshold = config?.thresholds?.instability ?? 0.85;
+      const items = top.map((p) => {
+        const warn = p.instability > threshold ? " \u26A0 unstable" : "";
+        return `${p.name}  Ca: ${p.afferent}  Ce: ${p.efferent}  I: ${p.instability.toFixed(2)}${warn}`;
+      });
+      ctx.ui?.success?.(`Coupling \u2014 avg instability: ${report.avgInstability.toFixed(2)}`, {
+        sections: [{ header: `Top ${top.length} by instability`, items }]
+      });
+      return { exitCode: 0 };
+    }
+  }
+});
 var cycles_default = defineCommand({
   id: "quality:cycles",
   description: "Detect circular dependencies in monorepo",
@@ -481,220 +495,93 @@ function outputCycles(cycles, flags, ui) {
 }
 var dead_code_default = defineCommand({
   id: "quality:dead-code",
-  description: "Detect and optionally remove dead (unreachable) source files",
+  description: "Detect unused files, exports, and deps via knip",
   handler: {
     async execute(ctx, input) {
-      const { ui, platform } = ctx;
-      const flags = "flags" in input && typeof input.flags === "object" && input.flags !== null ? input.flags : input;
-      if (flags["list-backups"]) {
-        const backups = listBackups(ctx.cwd);
-        if (flags.json) {
-          ui?.json?.(backups);
-        } else {
-          outputBackupList(backups, ui);
-        }
-        return { exitCode: 0, result: backups };
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const cfg = config ?? defaultQualityConfig;
+      if (!cfg.knip.enabled) {
+        ctx.ui?.success?.("knip is disabled in config (knip.enabled = false)");
+        return { exitCode: 0 };
       }
-      if (flags.restore) {
-        try {
-          const result2 = await restoreFromBackup(ctx.cwd, flags.restore);
-          if (flags.json) {
-            ui?.json?.(result2);
-          } else {
-            ui?.success?.(`Restored ${result2.restoredFiles} file(s) from backup ${flags.restore}`, {});
-            if (result2.restoredExports > 0) {
-              ui?.info?.(`Note: ${result2.restoredExports} package.json export(s) were cleaned. You may need to rebuild.`);
-            }
-          }
-          return { exitCode: 0 };
-        } catch (err) {
-          if (flags.json) {
-            ui?.json?.({ error: err instanceof Error ? err.message : String(err) });
-          } else {
-            ui?.error?.(err instanceof Error ? err.message : String(err));
-          }
-          return { exitCode: 1 };
-        }
+      const report = await runKnip({ shell: ctx.api.shell, rootDir: cwd });
+      if (flags.json) {
+        ctx.ui?.json?.(report);
+        return { exitCode: report.totalIssues > 0 ? 1 : 0 };
       }
-      const cacheKey = `${CACHE_KEYS.DEAD_CODE}:${flags.package || "all"}`;
-      if (!flags.refresh && !flags["auto-remove"]) {
-        const cached = await platform.cache.get(cacheKey);
-        if (cached) {
-          outputDeadCodeReport({ ...cached, cached: true }, flags, ui);
-          return { exitCode: cached.summary.totalDead > 0 ? 1 : 0, result: cached };
-        }
+      if (report.totalIssues === 0) {
+        ctx.ui?.success?.("No dead code detected");
+        return { exitCode: 0 };
       }
-      const result = await scanDeadFiles(ctx.cwd, {
-        packageFilter: flags.package,
-        verbose: flags.verbose
-      });
-      await platform.cache.set(cacheKey, result, 5 * 60 * 1e3);
-      await platform.analytics.track("quality:dead-code", {
-        totalPackages: result.summary.totalPackages,
-        totalFiles: result.summary.totalFiles,
-        totalDead: result.summary.totalDead,
-        totalDeadBytes: result.summary.totalDeadBytes,
-        duration: result.duration,
-        autoRemove: !!flags["auto-remove"],
-        dryRun: !!flags["dry-run"]
-      });
-      if (flags["auto-remove"]) {
-        if (result.summary.totalDead === 0) {
-          if (flags.json) {
-            ui?.json?.({ message: "No dead files found", ...result });
-          } else {
-            ui?.success?.("No dead files found. Nothing to remove.", {});
-          }
-          return { exitCode: 0, result };
-        }
-        const removalResult = await removeDeadFiles(ctx.cwd, result, {
-          dryRun: flags["dry-run"]
+      const sections = [];
+      if (report.unusedFiles.length > 0) {
+        sections.push({
+          header: `Unused files (${report.unusedFiles.length})`,
+          items: report.unusedFiles
         });
-        if (flags.json) {
-          ui?.json?.(removalResult);
-        } else {
-          outputRemovalReport(removalResult, flags, ui);
-        }
-        return { exitCode: 0, result: removalResult };
       }
-      outputDeadCodeReport({ ...result, cached: false }, flags, ui);
-      return {
-        exitCode: result.summary.totalDead > 0 ? 1 : 0,
-        result
-      };
-    }
-  }
-});
-function outputDeadCodeReport(result, flags, ui) {
-  if (flags.json) {
-    ui?.json?.(result);
-    return;
-  }
-  const sections = [];
-  const packagesWithDead = result.packages.filter((p) => p.deadFiles.length > 0);
-  if (packagesWithDead.length > 0) {
-    const items = [];
-    for (const pkg of packagesWithDead) {
-      items.push(`${pkg.packageName} (${pkg.deadFiles.length} dead file${pkg.deadFiles.length === 1 ? "" : "s"})`);
-      for (const dead of pkg.deadFiles.slice(0, 5)) {
-        const sizeKb = (dead.sizeBytes / 1024).toFixed(1);
-        items.push(`  ${dead.relativePath} (${sizeKb} KB)`);
+      if (report.unusedExports.length > 0) {
+        sections.push({
+          header: `Unused exports (${report.unusedExports.length})`,
+          items: report.unusedExports.map((e) => `${e.file}  ${e.symbol}`)
+        });
       }
-      if (pkg.deadFiles.length > 5) {
-        items.push(`  ... and ${pkg.deadFiles.length - 5} more`);
+      if (report.unusedDependencies.length > 0) {
+        sections.push({
+          header: `Unused dependencies (${report.unusedDependencies.length})`,
+          items: report.unusedDependencies.map((d) => `${d.package}  in ${d.workspace}`)
+        });
       }
-    }
-    sections.push({ header: "Dead Files", items });
-  }
-  if (flags.verbose) {
-    for (const pkg of result.packages) {
-      if (pkg.entryPoints.length > 0) {
-        const items = pkg.entryPoints.slice(0, 10).map((ep) => `  ${ep}`);
-        if (pkg.entryPoints.length > 10) {
-          items.push(`  ... and ${pkg.entryPoints.length - 10} more`);
-        }
-        sections.push({ header: `Entry Points: ${pkg.packageName}`, items });
+      if (report.unlistedDependencies.length > 0) {
+        sections.push({
+          header: `Unlisted dependencies (${report.unlistedDependencies.length})`,
+          items: report.unlistedDependencies.map((d) => `${d.package}  in ${d.workspace}`)
+        });
       }
+      ctx.ui?.error?.(`${report.totalIssues} dead code issue(s) found`, { sections });
+      return { exitCode: 1 };
     }
   }
-  const allWarnings = result.packages.flatMap((p) => p.warnings);
-  if (allWarnings.length > 0) {
-    sections.push({
-      header: "Warnings",
-      items: allWarnings.slice(0, 10)
-    });
-  }
-  const totalDeadKb = (result.summary.totalDeadBytes / 1024).toFixed(1);
-  const summaryItems = [
-    `Packages scanned: ${result.summary.totalPackages}`,
-    `Total source files: ${result.summary.totalFiles}`,
-    `Alive files: ${result.summary.totalAlive}`,
-    `Dead files: ${result.summary.totalDead}`,
-    result.summary.totalDead > 0 ? `Dead code size: ${totalDeadKb} KB` : null,
-    result.summary.emptyDirectories.length > 0 ? `Empty directories: ${result.summary.emptyDirectories.length}` : null,
-    `Duration: ${(result.duration / 1e3).toFixed(1)}s`,
-    result.cached ? "(cached \u2014 use --refresh to rescan)" : null
-  ].filter(Boolean);
-  sections.push({ header: "Summary", items: summaryItems });
-  if (result.summary.totalDead > 0) {
-    sections.push({
-      header: "Next Steps",
-      items: [
-        "Run with --auto-remove --dry-run to preview removal",
-        "Run with --auto-remove to remove and create backup",
-        "Run with --verbose to see entry points"
-      ]
-    });
-  }
-  const title = result.summary.totalDead === 0 ? "No dead files found" : `${result.summary.totalDead} dead file(s) found`;
-  ui?.success?.("Dead code analysis completed", { title, sections });
-}
-function outputRemovalReport(result, flags, ui) {
-  const isDryRun = flags["dry-run"];
-  const prefix = isDryRun ? "[DRY RUN] Would" : "Successfully";
-  const sections = [];
-  const items = [
-    `${prefix} remove ${result.filesRemoved} file(s)`,
-    `${prefix} free ${(result.bytesRemoved / 1024).toFixed(1)} KB`
-  ];
-  if (result.emptyDirsRemoved > 0) {
-    items.push(`${prefix} remove ${result.emptyDirsRemoved} empty director${result.emptyDirsRemoved === 1 ? "y" : "ies"}`);
-  }
-  if (result.exportsCleanedUp > 0) {
-    items.push(`${prefix} clean ${result.exportsCleanedUp} package.json export(s)`);
-  }
-  sections.push({ header: isDryRun ? "Preview" : "Removal Complete", items });
-  if (!isDryRun) {
-    sections.push({
-      header: "Backup",
-      items: [
-        `Backup ID: ${result.backupId}`,
-        `To restore: pnpm kb quality:dead-code --restore ${result.backupId}`
-      ]
-    });
-  }
-  const fileItems = [];
-  for (const file of result.manifest.removedFiles.slice(0, 10)) {
-    const sizeKb = (file.sizeBytes / 1024).toFixed(1);
-    fileItems.push(`${file.backupPath} (${sizeKb} KB)`);
-  }
-  if (result.manifest.removedFiles.length > 10) {
-    fileItems.push(`... and ${result.manifest.removedFiles.length - 10} more`);
-  }
-  sections.push({ header: "Files", items: fileItems });
-  const title = isDryRun ? `[DRY RUN] Would remove ${result.filesRemoved} file(s)` : `Removed ${result.filesRemoved} file(s)`;
-  ui?.success?.(title, { title, sections });
-}
-function outputBackupList(backups, ui) {
-  if (backups.length === 0) {
-    ui?.info?.("No backups found.");
-    return;
-  }
-  const sections = [];
-  for (const backup of backups) {
-    const date = new Date(backup.createdAt).toLocaleString();
-    const items = [
-      `Date: ${date}`,
-      `Git: ${backup.gitBranch} @ ${backup.gitSha.slice(0, 8)}`,
-      `Files: ${backup.totalFilesRemoved}`,
-      `Size: ${(backup.totalBytesRemoved / 1024).toFixed(1)} KB`,
-      `Restore: pnpm kb quality:dead-code --restore ${backup.id}`
-    ];
-    sections.push({ header: `Backup: ${backup.id}`, items });
-  }
-  ui?.success?.(`${backups.length} backup(s) found`, {
-    title: "Dead Code Backups",
-    sections
-  });
-}
+});
 var fix_deps_default = defineCommand({
   id: "quality:fix-deps",
   description: "Auto-fix dependency issues",
   handler: {
+    async intent(_ctx, input) {
+      const flags = input.flags;
+      const removeUnused = flags["remove-unused"] || flags.all;
+      const addMissing = flags["add-missing"] || flags.all;
+      const alignVersions = flags["align-versions"] || flags.all;
+      const packages = findPackages(_ctx.cwd);
+      const preview = await runAnalysis(packages, { removeUnused, addMissing, alignVersions, dryRun: true });
+      const operations = [
+        ...preview.alignedDeps.map((a) => ({
+          type: "update",
+          resource: "dependency",
+          details: { dep: a.dep, from: a.from, to: a.to, packages: a.packages }
+        })),
+        ...preview.addedDeps.map((a) => ({
+          type: "create",
+          resource: "dependency",
+          details: { package: a.package, dep: a.dep, version: a.version }
+        })),
+        ...preview.removedDeps.map((r) => ({
+          type: "delete",
+          resource: "dependency",
+          details: { package: r.package, dep: r.dep }
+        }))
+      ];
+      const total = operations.length;
+      return {
+        summary: total > 0 ? `Fix ${total} dependency issue(s) across ${preview.packagesScanned} packages` : `No dependency issues found in ${preview.packagesScanned} packages`,
+        operations
+      };
+    },
     async execute(ctx, input) {
       const { ui, platform } = ctx;
-      const flags = "flags" in input && typeof input.flags === "object" && input.flags !== null ? input.flags : input;
-      const dryRun = flags["dry-run"] ?? false;
+      const flags = input.flags;
       const removeUnused = flags["remove-unused"] || flags.all;
       const addMissing = flags["add-missing"] || flags.all;
       const alignVersions = flags["align-versions"] || flags.all;
@@ -705,52 +592,45 @@ var fix_deps_default = defineCommand({
         return { exitCode: 0 };
       }
       if (!removeUnused && !addMissing && !alignVersions) {
-        ui?.error?.("No fix options specified. Use --remove-unused, --add-missing, --align-versions, or --all");
+        validationError(ctx, "No fix options specified", "Use --remove-unused, --add-missing, --align-versions, or --all", flags.json);
         return { exitCode: 1 };
       }
       const loader = useLoader("Scanning packages...");
       loader.start();
-      const result = {
-        packagesScanned: 0,
-        removedDeps: [],
-        addedDeps: [],
-        alignedDeps: [],
-        dryRun
-      };
       const packages = findPackages(ctx.cwd);
-      result.packagesScanned = packages.length;
       loader.update({ text: `Scanned ${packages.length} packages` });
-      if (alignVersions) {
-        loader.update({ text: "Analyzing duplicate dependencies..." });
-        const aligned = await alignDuplicateVersions(packages, dryRun);
-        result.alignedDeps = aligned;
-      }
-      if (addMissing) {
-        loader.update({ text: "Checking for missing workspace dependencies..." });
-        const added = await addMissingWorkspaceDeps(packages, dryRun);
-        result.addedDeps = added;
-      }
-      if (removeUnused) {
-        loader.update({ text: "Checking for unused dependencies..." });
-        const removed = await removeUnusedDeps(packages, dryRun);
-        result.removedDeps = removed;
-      }
+      const result = await runAnalysis(packages, { removeUnused, addMissing, alignVersions, dryRun: false });
       loader.succeed("Dependency analysis completed");
       await platform.analytics.track("quality:fix-deps", {
-        dryRun,
+        dryRun: false,
         packagesScanned: result.packagesScanned,
         removedCount: result.removedDeps.length,
         addedCount: result.addedDeps.length,
         alignedCount: result.alignedDeps.length
       });
-      outputResults(result, flags, ui);
-      return {
-        exitCode: 0,
-        result
-      };
+      outputResults({ ...result, dryRun: false }, flags, ui);
+      return { exitCode: 0, result };
     }
   }
 });
+async function runAnalysis(packages, opts) {
+  const result = {
+    packagesScanned: packages.length,
+    removedDeps: [],
+    addedDeps: [],
+    alignedDeps: []
+  };
+  if (opts.alignVersions) {
+    result.alignedDeps = await alignDuplicateVersions(packages, opts.dryRun);
+  }
+  if (opts.addMissing) {
+    result.addedDeps = await addMissingWorkspaceDeps(packages, opts.dryRun);
+  }
+  if (opts.removeUnused) {
+    result.removedDeps = await removeUnusedDeps(packages, opts.dryRun);
+  }
+  return result;
+}
 function findPackages(rootDir) {
   const packages = [];
   if (!fs.existsSync(rootDir)) {
@@ -761,8 +641,8 @@ function findPackages(rootDir) {
     if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
       continue;
     }
-    const repoPath = path3.join(rootDir, entry.name);
-    const packagesDir = path3.join(repoPath, "packages");
+    const repoPath = path.join(rootDir, entry.name);
+    const packagesDir = path.join(repoPath, "packages");
     if (!fs.existsSync(packagesDir)) {
       continue;
     }
@@ -771,7 +651,7 @@ function findPackages(rootDir) {
       if (!pkgDir.isDirectory()) {
         continue;
       }
-      const packageJsonPath = path3.join(packagesDir, pkgDir.name, "package.json");
+      const packageJsonPath = path.join(packagesDir, pkgDir.name, "package.json");
       if (fs.existsSync(packageJsonPath)) {
         const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
         packages.push({
@@ -845,12 +725,7 @@ async function alignDuplicateVersions(packages, dryRun) {
       continue;
     }
     for (const { version, packages: pkgNames } of versionCounts.slice(1)) {
-      aligned.push({
-        dep,
-        from: version,
-        to: targetVersion,
-        packages: pkgNames
-      });
+      aligned.push({ dep, from: version, to: targetVersion, packages: pkgNames });
       if (!dryRun) {
         for (const pkgName of pkgNames) {
           const pkg = packages.find((p) => p.name === pkgName);
@@ -879,8 +754,8 @@ async function addMissingWorkspaceDeps(packages, dryRun) {
     }
   }
   for (const pkg of packages) {
-    const packageDir = path3.dirname(pkg.path);
-    const srcDir = path3.join(packageDir, "src");
+    const packageDir = path.dirname(pkg.path);
+    const srcDir = path.join(packageDir, "src");
     if (!fs.existsSync(srcDir)) {
       continue;
     }
@@ -891,11 +766,7 @@ async function addMissingWorkspaceDeps(packages, dryRun) {
     };
     for (const imp of imports) {
       if (imp.startsWith("@kb-labs/") && workspacePackages.has(imp) && !currentDeps[imp]) {
-        added.push({
-          package: pkg.name,
-          dep: imp,
-          version: "workspace:*"
-        });
+        added.push({ package: pkg.name, dep: imp, version: "workspace:*" });
         if (!dryRun) {
           if (!pkg.json.dependencies) {
             pkg.json.dependencies = {};
@@ -911,8 +782,8 @@ async function addMissingWorkspaceDeps(packages, dryRun) {
 async function removeUnusedDeps(packages, dryRun) {
   const removed = [];
   for (const pkg of packages) {
-    const packageDir = path3.dirname(pkg.path);
-    const srcDir = path3.join(packageDir, "src");
+    const packageDir = path.dirname(pkg.path);
+    const srcDir = path.join(packageDir, "src");
     if (!fs.existsSync(srcDir)) {
       continue;
     }
@@ -926,10 +797,7 @@ async function removeUnusedDeps(packages, dryRun) {
         continue;
       }
       if (!imports.has(dep)) {
-        removed.push({
-          package: pkg.name,
-          dep
-        });
+        removed.push({ package: pkg.name, dep });
         if (!dryRun) {
           delete pkg.json.dependencies?.[dep];
           delete pkg.json.devDependencies?.[dep];
@@ -945,7 +813,7 @@ function scanImports(dir) {
   function walk(currentDir) {
     const entries = fs.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path3.join(currentDir, entry.name);
+      const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
       } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
@@ -1005,7 +873,7 @@ function outputStats(stats, flags, ui) {
     });
   }
   ui?.success?.("Dependency statistics", {
-    title: "\u{1F4CA} Dependency Statistics",
+    title: "Dependency Statistics",
     sections
   });
 }
@@ -1015,530 +883,245 @@ function outputResults(result, flags, ui) {
     return;
   }
   const sections = [];
-  const summaryItems = [
-    `Packages Scanned: ${result.packagesScanned}`,
-    `Mode: ${result.dryRun ? "\u{1F50D} Dry Run (no changes applied)" : "\u2705 Changes Applied"}`
-  ];
-  sections.push({ header: "Summary", items: summaryItems });
+  sections.push({
+    header: "Summary",
+    items: [`Packages Scanned: ${result.packagesScanned}`]
+  });
   if (result.alignedDeps.length > 0) {
-    const alignedItems = result.alignedDeps.map(
-      (a) => `${a.dep}: ${a.from} \u2192 ${a.to} (${a.packages.length} packages)`
-    );
-    sections.push({ header: "Aligned Versions", items: alignedItems.slice(0, 10) });
+    const items = result.alignedDeps.slice(0, 10).map((a) => `${a.dep}: ${a.from} \u2192 ${a.to} (${a.packages.length} packages)`);
     if (result.alignedDeps.length > 10) {
-      const lastSection = sections[sections.length - 1];
-      if (lastSection) {
-        lastSection.items.push(`... and ${result.alignedDeps.length - 10} more`);
-      }
+      items.push(`... and ${result.alignedDeps.length - 10} more`);
     }
+    sections.push({ header: "Aligned Versions", items });
   }
   if (result.addedDeps.length > 0) {
-    const addedItems = result.addedDeps.map((a) => `${a.package}: +${a.dep}`);
-    sections.push({ header: "Added Dependencies", items: addedItems.slice(0, 10) });
+    const items = result.addedDeps.slice(0, 10).map((a) => `${a.package}: +${a.dep}`);
     if (result.addedDeps.length > 10) {
-      const lastSection = sections[sections.length - 1];
-      if (lastSection) {
-        lastSection.items.push(`... and ${result.addedDeps.length - 10} more`);
-      }
+      items.push(`... and ${result.addedDeps.length - 10} more`);
     }
+    sections.push({ header: "Added Dependencies", items });
   }
   if (result.removedDeps.length > 0) {
-    const removedItems = result.removedDeps.map((r) => `${r.package}: -${r.dep}`);
-    sections.push({ header: "Removed Dependencies", items: removedItems.slice(0, 10) });
+    const items = result.removedDeps.slice(0, 10).map((r) => `${r.package}: -${r.dep}`);
     if (result.removedDeps.length > 10) {
-      const lastSection = sections[sections.length - 1];
-      if (lastSection) {
-        lastSection.items.push(`... and ${result.removedDeps.length - 10} more`);
-      }
+      items.push(`... and ${result.removedDeps.length - 10} more`);
     }
+    sections.push({ header: "Removed Dependencies", items });
   }
   if (result.alignedDeps.length === 0 && result.addedDeps.length === 0 && result.removedDeps.length === 0) {
-    sections.push({ header: "Result", items: ["\u2705 No issues found!"] });
+    sections.push({ header: "Result", items: ["No issues found!"] });
   }
-  if (result.dryRun && (result.alignedDeps.length > 0 || result.addedDeps.length > 0 || result.removedDeps.length > 0)) {
-    sections.push({
-      header: "Next Steps",
-      items: ["Remove --dry-run flag to apply changes", "Run `pnpm install` after applying changes"]
-    });
-  }
-  const title = result.dryRun ? "\u{1F50D} Dependency Fix Preview" : "\u2705 Dependency Fix Complete";
   ui?.success?.("Dependency fix completed", {
-    title,
+    title: "Dependency Fix Complete",
     sections
   });
 }
 var health_default = defineCommand({
   id: "quality:health",
-  description: "Check monorepo health score",
+  description: "Multidimensional health score: architecture, TypeScript, dead code, dependencies",
   handler: {
     async execute(ctx, input) {
-      const { ui, platform } = ctx;
-      const flags = "flags" in input && typeof input.flags === "object" && input.flags !== null ? input.flags : input;
-      const health = await calculateHealth(ctx.cwd, flags.package);
-      await platform.cache.set(CACHE_KEYS.HEALTH, health, 5 * 60 * 1e3);
-      await platform.analytics.track("quality:health", {
-        score: health.score,
-        grade: health.grade,
-        issueCount: health.issues.length,
-        packageSpecific: !!flags.package
-      });
-      outputHealth(health, flags, ui);
-      return {
-        exitCode: health.score < 60 ? 1 : 0,
-        result: health
-      };
-    }
-  }
-});
-function findPackages2(rootDir, specificPackage) {
-  const packages = [];
-  if (!fs.existsSync(rootDir)) {
-    return packages;
-  }
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
-      continue;
-    }
-    const repoPath = path3.join(rootDir, entry.name);
-    const packagesDir = path3.join(repoPath, "packages");
-    if (!fs.existsSync(packagesDir)) {
-      continue;
-    }
-    const packageDirs = fs.readdirSync(packagesDir, { withFileTypes: true });
-    for (const pkgDir of packageDirs) {
-      if (!pkgDir.isDirectory()) {
-        continue;
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const cfg = config ?? defaultQualityConfig;
+      const cached = await ctx.platform.cache.get(CACHE_KEYS.HEALTH);
+      if (cached && !flags.refresh) {
+        const health2 = cached;
+        outputHealth(health2, flags, ctx);
+        return { exitCode: health2.score < cfg.thresholds.health ? 1 : 0 };
       }
-      const packageJsonPath = path3.join(packagesDir, pkgDir.name, "package.json");
-      if (fs.existsSync(packageJsonPath)) {
-        if (specificPackage) {
-          const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-          if (pkgJson.name === specificPackage || pkgDir.name === specificPackage) {
-            packages.push(packageJsonPath);
-          }
-        } else {
-          packages.push(packageJsonPath);
-        }
+      const [layering, types] = await Promise.all([
+        analyzeLayering({ rootDir: cwd, layerMap: cfg.layers }),
+        analyzeTypes$1(cwd)
+      ]);
+      const coupling = analyzeCoupling({ rootDir: cwd, layerMap: cfg.layers });
+      let knip = { unusedFiles: [], unusedExports: [], unusedDependencies: [], unlistedDependencies: [], totalIssues: 0 };
+      if (cfg.knip.enabled) {
+        knip = await runKnip({ shell: ctx.api.shell, rootDir: cwd });
       }
+      const health = calculateHealth({
+        layering,
+        coupling,
+        types,
+        knip,
+        totalPackages: coupling.packages.length,
+        avgTestCoverage: null,
+        thresholds: cfg.thresholds
+      });
+      await ctx.platform.cache.set(CACHE_KEYS.HEALTH, health, CACHE_TTLS.FAST);
+      outputHealth(health, flags, ctx);
+      return { exitCode: health.score < cfg.thresholds.health ? 1 : 0 };
     }
   }
-  return packages;
-}
-async function calculateHealth(rootDir, specificPackage) {
-  const packages = findPackages2(rootDir, specificPackage);
-  let score = 100;
-  const issues = [];
-  const allDeps = /* @__PURE__ */ new Map();
-  for (const packagePath of packages) {
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    const deps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const [dep, version] of Object.entries(deps)) {
-      if (!allDeps.has(dep)) {
-        allDeps.set(dep, /* @__PURE__ */ new Set());
-      }
-      allDeps.get(dep).add(version);
-    }
-  }
-  const duplicates = Array.from(allDeps.entries()).filter(([_, versions]) => versions.size > 1).filter(([dep]) => !dep.startsWith("@kb-labs/"));
-  if (duplicates.length > 0) {
-    const penalty = Math.min(20, duplicates.length * 2);
-    score -= penalty;
-    issues.push({
-      type: "duplicates",
-      severity: "warning",
-      message: `${duplicates.length} duplicate dependencies (-${penalty})`
-    });
-  }
-  let missingReadmes = 0;
-  for (const packagePath of packages) {
-    const packageDir = path3.dirname(packagePath);
-    const readmePath = path3.join(packageDir, "README.md");
-    if (!fs.existsSync(readmePath)) {
-      missingReadmes++;
-    }
-  }
-  if (missingReadmes > 0) {
-    const penalty = Math.min(15, missingReadmes);
-    score -= penalty;
-    issues.push({
-      type: "missing-docs",
-      severity: "warning",
-      message: `${missingReadmes} packages missing README (-${penalty})`
-    });
-  }
-  let namingIssues = 0;
-  for (const packagePath of packages) {
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    const packageName = packageJson.name;
-    if (!packageName || !packageName.startsWith("@kb-labs/")) {
-      namingIssues++;
-    }
-  }
-  if (namingIssues > 0) {
-    const penalty = Math.min(10, namingIssues * 2);
-    score -= penalty;
-    issues.push({
-      type: "naming",
-      severity: "critical",
-      message: `${namingIssues} packages with naming issues (-${penalty})`
-    });
-  }
-  let missingTypes = 0;
-  for (const packagePath of packages) {
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    if (!packageJson.types && !packageJson.typings) {
-      missingTypes++;
-    }
-  }
-  if (missingTypes > 0) {
-    const penalty = Math.min(15, missingTypes);
-    score -= penalty;
-    issues.push({
-      type: "missing-types",
-      severity: "warning",
-      message: `${missingTypes} packages missing types field (-${penalty})`
-    });
-  }
-  let grade;
-  if (score >= 90) {
-    grade = "A";
-  } else if (score >= 80) {
-    grade = "B";
-  } else if (score >= 70) {
-    grade = "C";
-  } else if (score >= 60) {
-    grade = "D";
-  } else {
-    grade = "F";
-  }
-  return {
-    score: Math.max(0, score),
-    grade,
-    issues
-  };
-}
-function outputHealth(health, flags, ui) {
+});
+function outputHealth(health, flags, ctx) {
   if (flags.json) {
-    ui?.json?.(health);
+    ctx.ui?.json?.(health);
     return;
   }
-  const sections = [];
-  const scoreItems = [
-    `Score: ${health.score}/100`,
-    `Grade: ${health.grade}`,
-    `Status: ${health.score >= 80 ? "\u2705 Healthy" : health.score >= 60 ? "\u26A0\uFE0F Needs Attention" : "\u274C Critical"}`
-  ];
-  sections.push({ header: "Health Score", items: scoreItems });
-  if (health.issues.length > 0) {
-    const issueItems = health.issues.map((issue) => {
-      const icon = issue.severity === "critical" ? "\u274C" : issue.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
-      return `${icon} ${issue.message}`;
-    });
-    if (flags.detailed) {
-      sections.push({ header: "Issues (Detailed)", items: issueItems });
-    } else {
-      sections.push({ header: "Issues", items: issueItems });
-    }
-  } else {
-    sections.push({ header: "Issues", items: ["\u2705 No issues found!"] });
-  }
-  if (health.score < 90) {
-    const recommendations = [];
-    if (health.issues.some((i) => i.type === "duplicates")) {
-      recommendations.push("Run `kb quality:fix-deps --align-versions` to fix duplicates");
-    }
-    if (health.issues.some((i) => i.type === "missing-docs")) {
-      recommendations.push("Add README.md files to packages");
-    }
-    if (health.issues.some((i) => i.type === "missing-types")) {
-      recommendations.push('Add "types" field to package.json or enable dts generation');
-    }
-    if (recommendations.length > 0) {
-      sections.push({ header: "Recommendations", items: recommendations });
-    }
-  }
-  const title = health.score >= 80 ? "\u{1F49A} Monorepo Health Check - Healthy" : health.score >= 60 ? "\u{1F49B} Monorepo Health Check - Needs Attention" : "\u2764\uFE0F Monorepo Health Check - Critical";
-  ui?.success?.("Health check completed", {
-    title,
-    sections
+  const dimItems = Object.entries(health.dimensions).map(([key, dim]) => {
+    const details = dim.details.length > 0 ? `: ${dim.details.join(", ")}` : "";
+    return `${key}  ${dim.score}/100 (${dim.grade})${details}`;
+  });
+  ctx.ui?.success?.(`Health score: ${health.score}/100 (${health.grade})`, {
+    sections: [{ header: "Dimensions", items: dimItems }]
   });
 }
-var stats_default = defineCommand({
-  id: "quality:stats",
-  description: "Show monorepo statistics and health score",
+var history_default = defineCommand({
+  id: "quality:history",
+  description: "Show quality snapshot history and trends",
   handler: {
     async execute(ctx, input) {
-      const { ui, platform } = ctx;
-      const flags = "flags" in input && typeof input.flags === "object" && input.flags !== null ? input.flags : input;
-      if (!flags.refresh) {
-        const cached = await platform.cache.get(CACHE_KEYS.STATS);
-        if (cached) {
-          outputStats2(cached, flags, ui);
-          return { exitCode: 0 };
-        }
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const store = new QualitySnapshotStore(cwd, config?.maxSnapshots ?? defaultQualityConfig.maxSnapshots);
+      const { snapshots, delta, latest } = store.history();
+      if (snapshots.length === 0) {
+        ctx.ui?.success?.("No snapshots yet. Run `kb quality snapshot` first.");
+        return { exitCode: 0 };
       }
-      const stats = await collectStats(ctx.cwd);
-      if (flags.health) {
-        stats.health = calculateHealthScore(stats);
+      const limit = flags.limit ?? 10;
+      const recent = snapshots.slice(-limit).reverse();
+      if (flags.json) {
+        ctx.ui?.json?.({ snapshots: recent, delta, latest });
+        return { exitCode: 0 };
       }
-      await platform.cache.set(CACHE_KEYS.STATS, stats, 5 * 60 * 1e3);
-      await platform.analytics.track("quality:stats", {
-        packages: stats.overview.totalPackages,
-        repositories: stats.overview.totalRepositories,
-        withHealth: flags.health ?? false
+      const items = recent.map((s) => {
+        const date = new Date(s.timestamp).toLocaleString();
+        const branch = s.git.branch ? ` [${s.git.branch}]` : "";
+        return `${date}${branch} \u2014 ${s.score}/100 (${s.grade})  violations: ${s.counters.layeringViolations}  any: ${s.counters.anyCount}`;
       });
-      outputStats2(stats, flags, ui);
+      const sections = [
+        { header: `Last ${recent.length} snapshots`, items }
+      ];
+      if (delta) {
+        const sign = (n) => n > 0 ? `+${n}` : `${n}`;
+        sections.push({
+          header: "Delta vs previous snapshot",
+          items: [
+            `Score: ${sign(delta.score)}`,
+            `Layering violations: ${sign(delta.layeringViolations)}`,
+            `Any count: ${sign(delta.anyCount)}`,
+            `Unused files: ${sign(delta.unusedFiles)}`,
+            `Avg instability: ${sign(delta.avgInstability)}`
+          ]
+        });
+      }
+      ctx.ui?.success?.(`Quality history (${recent.length} snapshots)`, { sections });
       return { exitCode: 0 };
     }
   }
 });
-function findPackages3(rootDir) {
-  const packages = [];
-  if (!fs.existsSync(rootDir)) {
-    return packages;
-  }
-  const entries = fs.readdirSync(rootDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory() || !entry.name.startsWith("kb-labs-")) {
-      continue;
-    }
-    const repoPath = path3.join(rootDir, entry.name);
-    const packagesDir = path3.join(repoPath, "packages");
-    if (!fs.existsSync(packagesDir)) {
-      continue;
-    }
-    const packageDirs = fs.readdirSync(packagesDir, { withFileTypes: true });
-    for (const pkgDir of packageDirs) {
-      if (!pkgDir.isDirectory()) {
-        continue;
-      }
-      const packageJsonPath = path3.join(packagesDir, pkgDir.name, "package.json");
-      if (fs.existsSync(packageJsonPath)) {
-        packages.push(packageJsonPath);
-      }
-    }
-  }
-  return packages;
-}
-function calculateSize(packageDir) {
-  const srcDir = path3.join(packageDir, "src");
-  if (!fs.existsSync(srcDir)) {
-    return { files: 0, lines: 0, bytes: 0 };
+async function captureGit(shell, cwd) {
+  try {
+    const [c, b, m] = await Promise.all([
+      shell.exec("git", ["rev-parse", "--short", "HEAD"], { cwd, throwOnError: false }),
+      shell.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, throwOnError: false }),
+      shell.exec("git", ["log", "-1", "--format=%s"], { cwd, throwOnError: false })
+    ]);
+    if (!c.ok) return void 0;
+    return { commit: c.stdout.trim(), branch: b.stdout.trim() || "HEAD", message: m.stdout.trim() };
+  } catch {
+    return void 0;
   }
-  let files = 0;
-  let lines = 0;
-  let bytes = 0;
-  function walk(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-      } else if (entry.isFile() && /\.(ts|tsx|js|jsx)$/.test(entry.name)) {
-        files++;
-        const content = fs.readFileSync(fullPath, "utf-8");
-        lines += content.split("\n").length;
-        bytes += Buffer.byteLength(content, "utf-8");
-      }
-    }
-  }
-  walk(srcDir);
-  return { files, lines, bytes };
 }
-async function collectStats(rootDir) {
-  const packages = findPackages3(rootDir);
-  const stats = {
-    overview: {
-      totalPackages: 0,
-      totalRepositories: 0,
-      totalFiles: 0,
-      totalLines: 0,
-      totalBytes: 0
-    },
-    byRepository: {},
-    dependencies: {
-      total: 0,
-      workspace: 0,
-      external: 0,
-      duplicates: 0,
-      topUsed: []
-    },
-    health: {
-      score: 0,
-      grade: "F",
-      issues: []
-    },
-    largestPackages: []
-  };
-  const repos = /* @__PURE__ */ new Set();
-  const allDeps = /* @__PURE__ */ new Map();
-  for (const packagePath of packages) {
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
-    const packageName = packageJson.name;
-    if (!packageName || !packageName.startsWith("@kb-labs/")) {
-      continue;
-    }
-    stats.overview.totalPackages++;
-    const packageDir = path3.dirname(packagePath);
-    const repoName = path3.basename(path3.dirname(path3.dirname(packageDir)));
-    repos.add(repoName);
-    const size = calculateSize(packageDir);
-    stats.overview.totalFiles += size.files;
-    stats.overview.totalLines += size.lines;
-    stats.overview.totalBytes += size.bytes;
-    if (!stats.byRepository[repoName]) {
-      stats.byRepository[repoName] = {
-        name: repoName,
-        packages: 0,
-        files: 0,
-        lines: 0,
-        bytes: 0
+var snapshot_default = defineCommand({
+  id: "quality:snapshot",
+  description: "Collect all quality metrics and save a snapshot for trend tracking",
+  handler: {
+    async intent(_ctx, _input) {
+      return {
+        summary: "Collect all quality metrics and save snapshot for trend tracking",
+        operations: [
+          { type: "create", resource: "file", details: { path: ".kb/quality/snapshots/<timestamp>.json" } }
+        ]
       };
-    }
-    stats.byRepository[repoName].packages++;
-    stats.byRepository[repoName].files += size.files;
-    stats.byRepository[repoName].lines += size.lines;
-    stats.byRepository[repoName].bytes += size.bytes;
-    const deps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    for (const dep of Object.keys(deps)) {
-      stats.dependencies.total++;
-      if (dep.startsWith("@kb-labs/")) {
-        stats.dependencies.workspace++;
-      } else {
-        stats.dependencies.external++;
+    },
+    async execute(ctx, input) {
+      const { flags } = input;
+      const config = await useConfig();
+      const cwd = ctx.cwd ?? process.cwd();
+      const cfg = config ?? defaultQualityConfig;
+      ctx.ui?.success?.("Collecting quality metrics\u2026");
+      const [layering, coupling, types, git] = await Promise.all([
+        analyzeLayering({ rootDir: cwd, layerMap: cfg.layers }),
+        Promise.resolve(analyzeCoupling({ rootDir: cwd, layerMap: cfg.layers })),
+        analyzeTypes$1(cwd),
+        captureGit(ctx.api.shell, cwd)
+      ]);
+      let knip = { unusedFiles: [], unusedExports: [], unusedDependencies: [], unlistedDependencies: [], totalIssues: 0 };
+      if (cfg.knip.enabled) {
+        knip = await runKnip({ shell: ctx.api.shell, rootDir: cwd });
       }
-      allDeps.set(dep, (allDeps.get(dep) || 0) + 1);
-    }
-    stats.largestPackages.push({
-      name: packageName,
-      repository: repoName,
-      files: size.files,
-      lines: size.lines,
-      bytes: size.bytes
-    });
-  }
-  stats.overview.totalRepositories = repos.size;
-  stats.dependencies.duplicates = Array.from(allDeps.values()).filter((count) => count > 1).length;
-  stats.dependencies.topUsed = Array.from(allDeps.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count }));
-  stats.largestPackages.sort((a, b) => b.lines - a.lines);
-  stats.largestPackages = stats.largestPackages.slice(0, 10);
-  return stats;
-}
-function calculateHealthScore(stats) {
-  let score = 100;
-  const issues = [];
-  if (stats.dependencies.duplicates > 0) {
-    const penalty = Math.min(20, stats.dependencies.duplicates * 2);
-    score -= penalty;
-    issues.push({
-      type: "duplicates",
-      severity: "warning",
-      message: `${stats.dependencies.duplicates} duplicate dependencies (-${penalty})`
-    });
-  }
-  let grade;
-  if (score >= 90) {
-    grade = "A";
-  } else if (score >= 80) {
-    grade = "B";
-  } else if (score >= 70) {
-    grade = "C";
-  } else if (score >= 60) {
-    grade = "D";
-  } else {
-    grade = "F";
-  }
-  return {
-    score,
-    grade,
-    issues
-  };
-}
-function outputStats2(stats, flags, ui) {
-  if (flags.json) {
-    ui?.json?.(stats);
-    return;
-  }
-  if (flags.md) {
-    outputMarkdown(stats);
-    return;
-  }
-  const overviewItems = [
-    `Packages: ${stats.overview.totalPackages}`,
-    `Repositories: ${stats.overview.totalRepositories}`,
-    `Lines of Code: ${stats.overview.totalLines.toLocaleString()}`,
-    `Total Size: ${formatBytes(stats.overview.totalBytes)}`
-  ];
-  const sections = [
-    { header: "Overview", items: overviewItems }
-  ];
-  if (flags.health && stats.health) {
-    const healthItems = [
-      `Score: ${stats.health.score}/100 (Grade ${stats.health.grade})`
-    ];
-    if (stats.health.issues.length > 0) {
-      healthItems.push("");
-      healthItems.push("Issues:");
-      stats.health.issues.forEach((issue) => {
-        healthItems.push(`  ${issue.message}`);
+      const totalPackages = coupling.packages.length;
+      const health = calculateHealth({
+        layering,
+        coupling,
+        types,
+        knip,
+        totalPackages,
+        avgTestCoverage: null,
+        thresholds: cfg.thresholds
       });
+      const store = new QualitySnapshotStore(cwd, cfg.maxSnapshots);
+      const snap = store.save({
+        score: health.score,
+        grade: health.grade,
+        dimensions: health.dimensions,
+        counters: {
+          layeringViolations: layering.totalViolations,
+          avgInstability: coupling.avgInstability,
+          anyCount: types.packages.reduce((s, p) => s + p.anyCount, 0),
+          tsIgnoreCount: types.packages.reduce((s, p) => s + p.tsIgnoreCount, 0),
+          unusedFiles: knip.unusedFiles.length,
+          unusedDeps: knip.unusedDependencies.length
+        },
+        git: git ?? { commit: "", branch: "", message: "" }
+      });
+      if (flags.json) {
+        ctx.ui?.json?.(snap);
+      } else {
+        ctx.ui?.success?.(`Snapshot saved: score ${snap.score}/100 (${snap.grade})`, {
+          sections: [{
+            header: "Dimensions",
+            items: Object.entries(snap.dimensions).map(
+              ([k, d]) => `${k}  ${d.score}/100 (${d.grade})`
+            )
+          }]
+        });
+      }
+      return { exitCode: 0 };
     }
-    sections.push({ header: "Health Score", items: healthItems });
-  }
-  const topRepos = Object.values(stats.byRepository).sort((a, b) => b.lines - a.lines).slice(0, 5).map((repo) => `${repo.name}: ${repo.lines.toLocaleString()} lines, ${repo.packages} pkg(s)`);
-  if (topRepos.length > 0) {
-    sections.push({ header: "Top Repositories", items: topRepos });
   }
-  ui?.success?.("Statistics collected successfully", {
-    title: "\u{1F4CA} KB Labs Monorepo Statistics",
-    sections
-  });
-}
-function outputMarkdown(stats) {
-  console.log("# KB Labs Monorepo Statistics\n");
-  console.log("## Overview\n");
-  console.log("| Metric | Value |");
-  console.log("|--------|-------|");
-  console.log(`| Packages | ${stats.overview.totalPackages} |`);
-  console.log(`| Repositories | ${stats.overview.totalRepositories} |`);
-  console.log(`| Lines of Code | ${stats.overview.totalLines.toLocaleString()} |`);
-  console.log(`| Total Size | ${formatBytes(stats.overview.totalBytes)} |
-`);
-  if (stats.health) {
-    console.log("## Health Score\n");
-    console.log(`**${stats.health.score}/100** (Grade ${stats.health.grade})
-`);
-    if (stats.health.issues.length > 0) {
-      console.log("### Issues\n");
-      for (const issue of stats.health.issues) {
-        console.log(`- ${issue.message}`);
+});
+var stats_default = defineCommand({
+  id: "quality:stats",
+  description: "Monorepo statistics: packages, lines of code, size",
+  handler: {
+    async execute(ctx, input) {
+      const { flags } = input;
+      const cwd = ctx.cwd ?? process.cwd();
+      const stats = await calculateStats(cwd);
+      if (flags.json) {
+        ctx.ui?.json?.(stats);
+        return { exitCode: 0 };
       }
-      console.log("");
+      ctx.ui?.success?.("Monorepo statistics", {
+        sections: [{
+          header: "Overview",
+          items: [
+            `Packages: ${stats.packages}`,
+            `Lines of code: ${stats.loc.toLocaleString()}`,
+            `Size: ${stats.sizeFormatted}`
+          ]
+        }]
+      });
+      return { exitCode: 0 };
     }
   }
-  console.log("## By Repository\n");
-  console.log("| Repository | Packages | Lines | Size |");
-  console.log("|------------|----------|-------|------|");
-  for (const [name, repo] of Object.entries(stats.byRepository)) {
-    console.log(`| ${name} | ${repo.packages} | ${repo.lines.toLocaleString()} | ${formatBytes(repo.bytes)} |`);
-  }
-}
-function formatBytes(bytes) {
-  if (bytes === 0) {
-    return "0 B";
-  }
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
-}
+});
 var visualize_default = defineCommand({
   id: "quality:visualize",
   description: "Visualize dependency graph",
@@ -1556,9 +1139,9 @@ var visualize_default = defineCommand({
       } else if (flags.impact && flags.package) {
         outputImpact(graph, flags.package, flags, ui);
       } else if (flags.stats) {
-        outputStats3(graph, flags, ui);
+        outputStats2(graph, flags, ui);
       } else {
-        outputStats3(graph, flags, ui);
+        outputStats2(graph, flags, ui);
       }
       return { exitCode: 0 };
     }
@@ -1664,7 +1247,7 @@ function outputImpact(graph, packageName, flags, ui) {
     sections
   });
 }
-function outputStats3(graph, flags, ui) {
+function outputStats2(graph, flags, ui) {
   const { nodes } = graph;
   let totalDeps = 0;
   let maxDeps = 0;
@@ -1742,6 +1325,6 @@ function outputDot(graph, flags, ui) {
   }
 }
 
-export { build_order_default as buildOrder, check_builds_default as checkBuilds, check_tests_default as checkTests, check_types_default as checkTypes, cycles_default as cycles, dead_code_default as deadCode, fix_deps_default as fixDeps, health_default as health, stats_default as stats, visualize_default as visualize };
+export { build_order_default as buildOrder, check_builds_default as checkBuilds, check_layers_default as checkLayers, check_tests_default as checkTests, check_types_default as checkTypes, coupling_default as coupling, cycles_default as cycles, dead_code_default as deadCode, fix_deps_default as fixDeps, health_default as health, history_default as history, snapshot_default as snapshot, stats_default as stats, visualize_default as visualize };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map