@kb-labs/impact-core 0.5.0 → 2.7.0

package/dist/cli/index.js

@@ -0,0 +1,810 @@
+import { defineCommand } from '@kb-labs/sdk';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { execSync } from 'child_process';
+import { DEFAULT_IMPACT_CONFIG } from '@kb-labs/impact-contracts';
+
+// src/cli/commands/check.ts
+function findWorkspaceRoot(cwd) {
+  let dir = resolve(process.cwd());
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, ".gitmodules")) || existsSync(join(dir, ".kb", "kb.config.json"))) {
+      return dir;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  throw new Error("Could not find workspace root (no .gitmodules or .kb/kb.config.json found)");
+}
+function listSubRepos(workspaceRoot) {
+  const gitmodulesPath = join(workspaceRoot, ".gitmodules");
+  if (existsSync(gitmodulesPath)) {
+    return parseSubReposFromGitmodules(gitmodulesPath, workspaceRoot);
+  }
+  return scanFlatLayout(workspaceRoot);
+}
+function parseSubReposFromGitmodules(gitmodulesPath, workspaceRoot) {
+  const repos = [];
+  try {
+    const content = readFileSync(gitmodulesPath, "utf-8");
+    const pathMatches = content.matchAll(/^\s*path\s*=\s*(.+)$/gm);
+    for (const match of pathMatches) {
+      const relPath = (match[1] ?? "").trim();
+      if (!relPath) {
+        continue;
+      }
+      const fullPath = join(workspaceRoot, relPath);
+      if (!existsSync(join(fullPath, ".git")) && !existsSync(join(fullPath, "package.json"))) {
+        continue;
+      }
+      const parts = relPath.split("/");
+      const name = parts.at(-1) ?? relPath;
+      const category = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+      repos.push({ path: relPath, category, name });
+    }
+  } catch {
+  }
+  return repos;
+}
+function scanFlatLayout(workspaceRoot) {
+  const repos = [];
+  try {
+    for (const entry of readdirSync(workspaceRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = join(workspaceRoot, entry.name);
+      if (existsSync(join(fullPath, ".git")) || existsSync(join(fullPath, "package.json"))) {
+        repos.push({ path: entry.name, category: "", name: entry.name });
+      }
+    }
+  } catch {
+  }
+  return repos;
+}
+function git(cwd, args) {
+  try {
+    return execSync(`git ${args}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return "";
+  }
+}
+function getSubmodulePointer(workspaceRoot, repoPath) {
+  const out = git(workspaceRoot, `ls-tree HEAD ${repoPath}`);
+  const parts = out.split(/\s+/);
+  return parts[2] || "";
+}
+function getActualHead(fullPath) {
+  return git(fullPath, "rev-parse HEAD");
+}
+function findPackagesInRepo(workspaceRoot, repo) {
+  const fullRepoPath = join(workspaceRoot, repo.path);
+  const packagesDir = join(fullRepoPath, "packages");
+  const results = [];
+  if (!existsSync(packagesDir)) {
+    const pkgJsonPath = join(fullRepoPath, "package.json");
+    if (!existsSync(pkgJsonPath)) {
+      return [];
+    }
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (pkg.name?.startsWith("@kb-labs/")) {
+        results.push({ name: pkg.name, repo: repo.path, changedFiles: 1 });
+      }
+    } catch {
+    }
+    return results;
+  }
+  for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    const pkgJsonPath = join(packagesDir, entry.name, "package.json");
+    if (!existsSync(pkgJsonPath)) {
+      continue;
+    }
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (!pkg.name?.startsWith("@kb-labs/")) {
+        continue;
+      }
+      const pointerSha = getSubmodulePointer(workspaceRoot, repo.path);
+      let changedFiles = 0;
+      if (pointerSha) {
+        const diff = git(fullRepoPath, `diff ${pointerSha}..HEAD --name-only -- packages/${entry.name}/src/`);
+        changedFiles = diff ? diff.split("\n").filter(Boolean).length : 0;
+      } else {
+        const status = git(fullRepoPath, `status --porcelain -- packages/${entry.name}/src/`);
+        changedFiles = status ? status.split("\n").filter(Boolean).length : 0;
+      }
+      if (changedFiles > 0) {
+        results.push({ name: pkg.name, repo: repo.path, changedFiles });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function detectChangedPackages(workspaceRoot) {
+  const repos = listSubRepos(workspaceRoot);
+  const changed = [];
+  for (const repo of repos) {
+    const fullPath = join(workspaceRoot, repo.path);
+    if (!existsSync(join(fullPath, ".git"))) {
+      continue;
+    }
+    const pointerSha = getSubmodulePointer(workspaceRoot, repo.path);
+    const actualSha = getActualHead(fullPath);
+    if (pointerSha && pointerSha === actualSha) {
+      continue;
+    }
+    if (pointerSha === actualSha) {
+      const dirty = git(fullPath, "status --porcelain");
+      if (!dirty) {
+        continue;
+      }
+    }
+    const pkgs = findPackagesInRepo(workspaceRoot, repo);
+    changed.push(...pkgs);
+  }
+  return changed;
+}
+function discoverPackages(workspaceRoot) {
+  const repos = listSubRepos(workspaceRoot);
+  const packages = [];
+  for (const repo of repos) {
+    const fullRepoPath = join(workspaceRoot, repo.path);
+    const packagesDir = join(fullRepoPath, "packages");
+    const dirs = existsSync(packagesDir) ? readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => join(packagesDir, d.name)) : [fullRepoPath];
+    for (const dir of dirs) {
+      const pkgPath = join(dir, "package.json");
+      if (!existsSync(pkgPath)) {
+        continue;
+      }
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (!pkg.name?.startsWith("@kb-labs/")) {
+          continue;
+        }
+        const allDeps = { ...pkg.dependencies };
+        const kbDeps = Object.keys(allDeps).filter((d) => d.startsWith("@kb-labs/"));
+        packages.push({ name: pkg.name, repo: repo.path, deps: kbDeps });
+      } catch {
+      }
+    }
+  }
+  return packages;
+}
+function buildReverseDependencyGraph(workspaceRoot) {
+  const packages = discoverPackages(workspaceRoot);
+  const graph = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    graph.set(pkg.name, {
+      name: pkg.name,
+      repo: pkg.repo,
+      dependsOn: pkg.deps,
+      dependedBy: []
+    });
+  }
+  for (const pkg of packages) {
+    for (const dep of pkg.deps) {
+      const node = graph.get(dep);
+      if (node) {
+        node.dependedBy.push(pkg.name);
+      }
+    }
+  }
+  return graph;
+}
+
+// src/core/package-analyzer.ts
+function analyzePackageImpact(changed, graph) {
+  const direct = [];
+  const dependent = [];
+  const transitive = [];
+  const changedNames = new Set(changed.map((c) => c.name));
+  const seen = /* @__PURE__ */ new Set();
+  for (const pkg of changed) {
+    direct.push({
+      name: pkg.name,
+      repo: pkg.repo,
+      level: "direct",
+      changedFiles: pkg.changedFiles
+    });
+    seen.add(pkg.name);
+  }
+  const queue = [];
+  for (const name of changedNames) {
+    const node = graph.get(name);
+    if (!node) {
+      continue;
+    }
+    for (const dep of node.dependedBy) {
+      if (!seen.has(dep)) {
+        queue.push({ name: dep, depth: 1 });
+      }
+    }
+  }
+  while (queue.length > 0) {
+    const { name, depth } = queue.shift();
+    if (seen.has(name)) {
+      continue;
+    }
+    seen.add(name);
+    const node = graph.get(name);
+    if (!node) {
+      continue;
+    }
+    const reasonPkg = node.dependsOn.find((d) => changedNames.has(d) || seen.has(d));
+    const impact = {
+      name: node.name,
+      repo: node.repo,
+      level: depth === 1 ? "dependent" : "transitive",
+      reason: reasonPkg ? `depends on ${reasonPkg}` : void 0
+    };
+    if (depth === 1) {
+      dependent.push(impact);
+    } else {
+      transitive.push(impact);
+    }
+    for (const dep of node.dependedBy) {
+      if (!seen.has(dep)) {
+        queue.push({ name: dep, depth: depth + 1 });
+      }
+    }
+  }
+  return { direct, dependent, transitive };
+}
+function generateRecommendations(packages, docs) {
+  const recs = [];
+  if (packages.dependent.length > 0) {
+    const names = packages.dependent.map((p) => p.name).join(", ");
+    recs.push(`Rebuild ${names}`);
+  }
+  const testRepos = /* @__PURE__ */ new Set([
+    ...packages.dependent.map((p) => p.repo),
+    ...packages.transitive.map((p) => p.repo)
+  ]);
+  if (testRepos.size > 0) {
+    recs.push(`Run tests in ${[...testRepos].join(", ")}`);
+  }
+  for (const doc of docs.stale) {
+    if (doc.file) {
+      recs.push(`Regenerate ${doc.file}`);
+    }
+  }
+  for (const doc of docs.review) {
+    if (doc.file) {
+      recs.push(`Review ${doc.file}`);
+    }
+  }
+  for (const doc of docs.reindex) {
+    if (doc.command) {
+      recs.push(`Run: ${doc.command}`);
+    }
+  }
+  return recs;
+}
+
+// src/core/doc-analyzer.ts
+function matchesRule(packageName, pattern) {
+  if (pattern === packageName) {
+    return true;
+  }
+  if (pattern === "__new_package__") {
+    return false;
+  }
+  if (pattern.startsWith("*")) {
+    return packageName.endsWith(pattern.slice(1));
+  }
+  if (pattern.endsWith("*")) {
+    return packageName.startsWith(pattern.slice(0, -1));
+  }
+  return false;
+}
+function analyzeDocImpact(impactedPackages, config) {
+  const stale = [];
+  const review = [];
+  const reindex = [];
+  const seenDocs = /* @__PURE__ */ new Set();
+  for (const pkg of impactedPackages) {
+    for (const rule of config.docRules) {
+      if (!matchesRule(pkg.name, rule.match)) {
+        continue;
+      }
+      if (rule.action === "reindex") {
+        const key = `reindex:${rule.command ?? ""}`;
+        if (!seenDocs.has(key)) {
+          seenDocs.add(key);
+          reindex.push({
+            reason: `${pkg.name} changed`,
+            action: "reindex",
+            command: rule.command
+          });
+        }
+        continue;
+      }
+      for (const doc of rule.docs ?? []) {
+        const key = `${rule.action}:${doc}`;
+        if (seenDocs.has(key)) {
+          continue;
+        }
+        seenDocs.add(key);
+        const impact = {
+          file: doc,
+          reason: `${pkg.name} changed`,
+          action: rule.action,
+          command: rule.command
+        };
+        if (rule.action === "regenerate") {
+          stale.push(impact);
+        } else {
+          review.push(impact);
+        }
+      }
+    }
+  }
+  return { stale, review, reindex };
+}
+var TEST_DIRS = ["tests", "test", "__tests__"];
+var TEST_PATTERNS = [".test.ts", ".spec.ts", ".test.tsx", ".spec.tsx"];
+function findPackageDir(workspaceRoot, repo, packageName) {
+  const repoPath = join(workspaceRoot, repo);
+  const packagesDir = join(repoPath, "packages");
+  if (!existsSync(packagesDir)) {
+    return repoPath;
+  }
+  for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) {
+      continue;
+    }
+    const pkgJsonPath = join(packagesDir, entry.name, "package.json");
+    if (!existsSync(pkgJsonPath)) {
+      continue;
+    }
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (pkg.name === packageName) {
+        return join(packagesDir, entry.name);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function countTestFiles(dir) {
+  let count = 0;
+  function walk(d) {
+    if (!existsSync(d)) {
+      return;
+    }
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === "dist") {
+        continue;
+      }
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (TEST_PATTERNS.some((p) => entry.name.endsWith(p))) {
+        count++;
+      }
+    }
+  }
+  walk(dir);
+  return count;
+}
+function detectTests(packageDir) {
+  for (const testDir of TEST_DIRS) {
+    const fullPath = join(packageDir, testDir);
+    if (existsSync(fullPath)) {
+      const count = countTestFiles(fullPath);
+      if (count > 0) {
+        return { hasTests: true, testCount: count };
+      }
+    }
+  }
+  const srcDir = join(packageDir, "src");
+  if (existsSync(srcDir)) {
+    const count = countTestFiles(srcDir);
+    if (count > 0) {
+      return { hasTests: true, testCount: count };
+    }
+  }
+  return { hasTests: false, testCount: 0 };
+}
+function analyzeTestImpact(allImpacted, workspaceRoot) {
+  const mustRun = [];
+  const noTests = [];
+  for (const pkg of allImpacted) {
+    const pkgDir = findPackageDir(workspaceRoot, pkg.repo, pkg.name);
+    const { hasTests, testCount } = pkgDir ? detectTests(pkgDir) : { hasTests: false, testCount: 0 };
+    const impact = {
+      name: pkg.name,
+      repo: pkg.repo,
+      level: pkg.level,
+      reason: pkg.reason,
+      hasTests,
+      testCount: hasTests ? testCount : void 0,
+      command: hasTests ? `pnpm --filter ${pkg.name} run test` : void 0
+    };
+    if (hasTests) {
+      mustRun.push(impact);
+    } else {
+      noTests.push(impact);
+    }
+  }
+  return { mustRun, noTests };
+}
+
+// src/core/build-analyzer.ts
+function analyzeBuildImpact(allImpacted, graph) {
+  const impactedNames = new Set(allImpacted.map((p) => p.name));
+  const impactedMap = new Map(allImpacted.map((p) => [p.name, p]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const deps = /* @__PURE__ */ new Map();
+  for (const name of impactedNames) {
+    const node = graph.get(name);
+    const filteredDeps = (node?.dependsOn ?? []).filter((d) => impactedNames.has(d));
+    deps.set(name, filteredDeps);
+    inDegree.set(name, filteredDeps.length);
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    const node = graph.get(current);
+    if (node) {
+      for (const dependent of node.dependedBy) {
+        if (!impactedNames.has(dependent)) {
+          continue;
+        }
+        const deg = (inDegree.get(dependent) ?? 1) - 1;
+        inDegree.set(dependent, deg);
+        if (deg === 0) {
+          queue.push(dependent);
+        }
+      }
+    }
+  }
+  for (const name of impactedNames) {
+    if (!sorted.includes(name)) {
+      sorted.push(name);
+    }
+  }
+  const steps = sorted.map((name, idx) => {
+    const pkg = impactedMap.get(name);
+    return {
+      name: pkg.name,
+      repo: pkg.repo,
+      level: pkg.level,
+      order: idx + 1,
+      reason: pkg.reason
+    };
+  });
+  const filterArgs = sorted.map((name) => `--filter ${name}`).join(" ");
+  const command = sorted.length > 0 ? `pnpm ${filterArgs} run build` : "";
+  return {
+    steps,
+    command,
+    totalPackages: steps.length
+  };
+}
+async function loadImpactRules(useConfigFn) {
+  if (useConfigFn) {
+    try {
+      const config = await useConfigFn();
+      if (config?.docRules?.length) {
+        return { docRules: config.docRules };
+      }
+    } catch {
+    }
+  }
+  return DEFAULT_IMPACT_CONFIG;
+}
+
+// src/core/formatter.ts
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+function formatHumanReadable(result) {
+  const lines = [];
+  lines.push(`${BOLD}\u{1F4CA} Impact Analysis${RESET}`);
+  lines.push("");
+  const { direct, dependent, transitive } = result.packages;
+  const totalPkgs = direct.length + dependent.length + transitive.length;
+  if (totalPkgs > 0) {
+    lines.push(`${BOLD}\u{1F4E6} Package Impact${RESET}`);
+    if (direct.length > 0) {
+      lines.push(`  ${GREEN}Direct (${direct.length}):${RESET}`);
+      for (const p of direct) {
+        lines.push(`    ${p.name} ${DIM}(${p.repo})${RESET} \u2014 ${p.changedFiles} file${p.changedFiles === 1 ? "" : "s"} changed`);
+      }
+    }
+    if (dependent.length > 0) {
+      lines.push(`  ${YELLOW}Dependent (${dependent.length}):${RESET}`);
+      for (const p of dependent) {
+        lines.push(`    ${p.name} ${DIM}\u2190 ${p.reason}${RESET}`);
+      }
+    }
+    if (transitive.length > 0) {
+      lines.push(`  ${DIM}Transitive (${transitive.length}):${RESET}`);
+      for (const p of transitive) {
+        lines.push(`    ${p.name} ${DIM}\u2190 ${p.reason}${RESET}`);
+      }
+    }
+    lines.push("");
+  }
+  const { steps: buildSteps, command: buildCommand, totalPackages: buildTotal } = result.build;
+  if (buildTotal > 0) {
+    lines.push(`${BOLD}\u{1F528} Build Impact${RESET}`);
+    lines.push(`  ${YELLOW}Rebuild (${buildTotal} packages in order):${RESET}`);
+    for (const b of buildSteps) {
+      const reason = b.level === "direct" ? "changed" : b.reason ?? "";
+      lines.push(`    ${DIM}${b.order}.${RESET} ${b.name} ${DIM}\u2190 ${reason}${RESET}`);
+    }
+    if (buildCommand) {
+      lines.push("");
+      lines.push(`  ${CYAN}\u2192 ${buildCommand}${RESET}`);
+    }
+    lines.push("");
+  }
+  const { stale, review, reindex } = result.docs;
+  const totalDocs = stale.length + review.length + reindex.length;
+  if (totalDocs > 0) {
+    lines.push(`${BOLD}\u{1F4C4} Doc Impact${RESET}`);
+    if (stale.length > 0) {
+      lines.push(`  ${YELLOW}Stale (${stale.length}):${RESET}`);
+      for (const d of stale) {
+        lines.push(`    ${d.file} \u2014 ${d.reason}`);
+        if (d.command) {
+          lines.push(`    ${CYAN}\u2192 Run: ${d.command}${RESET}`);
+        }
+      }
+    }
+    if (review.length > 0) {
+      lines.push(`  ${GREEN}Review (${review.length}):${RESET}`);
+      for (const d of review) {
+        lines.push(`    ${d.file} \u2014 ${d.reason}`);
+      }
+    }
+    if (reindex.length > 0) {
+      lines.push(`  ${CYAN}Reindex (${reindex.length}):${RESET}`);
+      for (const d of reindex) {
+        lines.push(`    ${d.reason}`);
+        if (d.command) {
+          lines.push(`    ${CYAN}\u2192 Run: ${d.command}${RESET}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  const { mustRun, noTests } = result.tests;
+  const totalTests = mustRun.length + noTests.length;
+  if (totalTests > 0) {
+    lines.push(`${BOLD}\u{1F9EA} Test Impact${RESET}`);
+    if (mustRun.length > 0) {
+      lines.push(`  ${GREEN}Must run (${mustRun.length}):${RESET}`);
+      for (const t of mustRun) {
+        const count = t.testCount ? ` \u2014 ${t.testCount} test file${t.testCount === 1 ? "" : "s"}` : "";
+        const reason = t.level === "direct" ? "changed" : t.reason ?? "";
+        lines.push(`    ${t.name}${count} ${DIM}\u2190 ${reason}${RESET}`);
+        if (t.command) {
+          lines.push(`    ${CYAN}\u2192 ${t.command}${RESET}`);
+        }
+      }
+    }
+    if (noTests.length > 0) {
+      lines.push(`  ${RED}\u26A0\uFE0F  No tests (${noTests.length}):${RESET}`);
+      for (const t of noTests) {
+        const reason = t.level === "direct" ? "changed, NO TESTS" : `${t.reason}, NO TESTS`;
+        lines.push(`    ${RED}${t.name}${RESET} ${DIM}\u2190 ${reason}${RESET}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.recommendations.length > 0) {
+    lines.push(`${BOLD}\u26A0\uFE0F  Recommendations:${RESET}`);
+    for (const rec of result.recommendations) {
+      lines.push(`  \u2022 ${rec}`);
+    }
+    lines.push("");
+  }
+  if (totalPkgs === 0 && totalDocs === 0 && totalTests === 0) {
+    lines.push(`${GREEN}\u2705 No impact detected.${RESET}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/check.ts
+var EMPTY_RESULT = {
+  packages: { direct: [], dependent: [], transitive: [] },
+  docs: { stale: [], review: [], reindex: [] },
+  tests: { mustRun: [], noTests: [] },
+  build: { steps: [], command: "", totalPackages: 0 },
+  recommendations: []
+};
+var check_default = defineCommand({
+  id: "impact:check",
+  description: "Full impact analysis (packages + docs)",
+  handler: {
+    async execute(ctx, input) {
+      const flags = input.flags ?? input;
+      let root;
+      try {
+        root = findWorkspaceRoot();
+      } catch {
+        if (flags.json) {
+          ctx.ui?.json?.(EMPTY_RESULT);
+        } else {
+          ctx.ui?.warn?.("Could not find workspace root");
+        }
+        return { exitCode: 1 };
+      }
+      const changed = detectChangedPackages(root);
+      if (changed.length === 0) {
+        if (flags.json) {
+          ctx.ui?.json?.(EMPTY_RESULT);
+        } else {
+          ctx.ui?.success?.("No changes detected");
+        }
+        return { exitCode: 0, result: EMPTY_RESULT };
+      }
+      const graph = buildReverseDependencyGraph(root);
+      const packages = analyzePackageImpact(changed, graph);
+      const useConfigFn = async () => {
+        try {
+          const { useConfig } = await import('@kb-labs/sdk');
+          return await useConfig();
+        } catch {
+          return void 0;
+        }
+      };
+      const rules = await loadImpactRules(useConfigFn);
+      const allImpacted = [...packages.direct, ...packages.dependent, ...packages.transitive];
+      const docs = analyzeDocImpact(allImpacted, rules);
+      const tests = analyzeTestImpact(allImpacted, root);
+      const build = analyzeBuildImpact(allImpacted, graph);
+      const recommendations = generateRecommendations(packages, docs);
+      const result = { packages, docs, tests, build, recommendations };
+      if (flags.json) {
+        ctx.ui?.json?.(result);
+      } else {
+        ctx.ui?.write?.(formatHumanReadable(result));
+      }
+      return { exitCode: 0, result };
+    }
+  }
+});
+var packages_default = defineCommand({
+  id: "impact:packages",
+  description: "Package dependency impact analysis",
+  handler: {
+    async execute(ctx, input) {
+      const flags = input.flags ?? input;
+      let root;
+      try {
+        root = findWorkspaceRoot();
+      } catch {
+        if (flags.json) {
+          ctx.ui?.json?.({ packages: { direct: [], dependent: [], transitive: [] } });
+        } else {
+          ctx.ui?.warn?.("Could not find workspace root");
+        }
+        return { exitCode: 1 };
+      }
+      const changed = detectChangedPackages(root);
+      if (changed.length === 0) {
+        const empty = { packages: { direct: [], dependent: [], transitive: [] }, tests: { mustRun: [], noTests: [] }, recommendations: [] };
+        if (flags.json) {
+          ctx.ui?.json?.(empty);
+        } else {
+          ctx.ui?.success?.("No changes detected");
+        }
+        return { exitCode: 0, result: empty };
+      }
+      const graph = buildReverseDependencyGraph(root);
+      const packages = analyzePackageImpact(changed, graph);
+      const allImpacted = [...packages.direct, ...packages.dependent, ...packages.transitive];
+      const tests = analyzeTestImpact(allImpacted, root);
+      const build = analyzeBuildImpact(allImpacted, graph);
+      const recommendations = generateRecommendations(packages, { stale: [], review: [], reindex: [] });
+      const result = { packages, tests, build, recommendations };
+      if (flags.json) {
+        ctx.ui?.json?.(result);
+      } else {
+        ctx.ui?.write?.(formatHumanReadable({
+          packages,
+          docs: { stale: [], review: [], reindex: [] },
+          tests,
+          build,
+          recommendations
+        }));
+      }
+      return { exitCode: 0, result };
+    }
+  }
+});
+var docs_default = defineCommand({
+  id: "impact:docs",
+  description: "Documentation impact analysis",
+  handler: {
+    async execute(ctx, input) {
+      const flags = input.flags ?? input;
+      let root;
+      try {
+        root = findWorkspaceRoot();
+      } catch {
+        if (flags.json) {
+          ctx.ui?.json?.({ docs: { stale: [], review: [], reindex: [] } });
+        } else {
+          ctx.ui?.warn?.("Could not find workspace root");
+        }
+        return { exitCode: 1 };
+      }
+      const changed = detectChangedPackages(root);
+      if (changed.length === 0) {
+        const empty = { docs: { stale: [], review: [], reindex: [] }, recommendations: [] };
+        if (flags.json) {
+          ctx.ui?.json?.(empty);
+        } else {
+          ctx.ui?.success?.("No changes detected");
+        }
+        return { exitCode: 0, result: empty };
+      }
+      const graph = buildReverseDependencyGraph(root);
+      const packages = analyzePackageImpact(changed, graph);
+      const useConfigFn = async () => {
+        try {
+          const { useConfig } = await import('@kb-labs/sdk');
+          return await useConfig();
+        } catch {
+          return void 0;
+        }
+      };
+      const rules = await loadImpactRules(useConfigFn);
+      const allImpacted = [...packages.direct, ...packages.dependent];
+      const docs = analyzeDocImpact(allImpacted, rules);
+      const recommendations = [];
+      for (const d of docs.stale) {
+        if (d.command) {
+          recommendations.push(`Run: ${d.command}`);
+        }
+      }
+      for (const d of docs.reindex) {
+        if (d.command) {
+          recommendations.push(`Run: ${d.command}`);
+        }
+      }
+      const result = { docs, recommendations };
+      if (flags.json) {
+        ctx.ui?.json?.(result);
+      } else {
+        ctx.ui?.write?.(formatHumanReadable({
+          packages: { direct: [], dependent: [], transitive: [] },
+          docs,
+          tests: { mustRun: [], noTests: [] },
+          build: { steps: [], command: "", totalPackages: 0 },
+          recommendations
+        }));
+      }
+      return { exitCode: 0, result };
+    }
+  }
+});
+
+export { check_default as checkCommand, docs_default as docsCommand, packages_default as packagesCommand };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map