@harness-engineering/cli 1.8.2 → 1.9.0

package/dist/{chunk-SAB3VXOW.js → chunk-CGSHUJES.js}

@@ -4969,6 +4969,15 @@ var FAILURES_FILE = "failures.md";
 var HANDOFF_FILE = "handoff.json";
 var GATE_CONFIG_FILE = "gate.json";
 var INDEX_FILE2 = "index.json";
+var MAX_CACHE_ENTRIES = 8;
+var learningsCacheMap = /* @__PURE__ */ new Map();
+var failuresCacheMap = /* @__PURE__ */ new Map();
+function evictIfNeeded(map) {
+  if (map.size > MAX_CACHE_ENTRIES) {
+    const oldest = map.keys().next().value;
+    if (oldest !== void 0) map.delete(oldest);
+  }
+}
 async function getStateDir(projectPath, stream) {
   const streamsIndexPath = path3.join(projectPath, HARNESS_DIR2, "streams", INDEX_FILE2);
   const hasStreams = fs4.existsSync(streamsIndexPath);
@@ -5066,25 +5075,35 @@ async function loadRelevantLearnings(projectPath, skillName, stream) {
     if (!fs4.existsSync(learningsPath)) {
       return Ok([]);
     }
-    const content = fs4.readFileSync(learningsPath, "utf-8");
-    const lines = content.split("\n");
-    const entries = [];
-    let currentBlock = [];
-    for (const line of lines) {
-      if (line.startsWith("# ")) continue;
-      const isDatedBullet = /^- \*\*\d{4}-\d{2}-\d{2}/.test(line);
-      const isHeading = /^## \d{4}-\d{2}-\d{2}/.test(line);
-      if (isDatedBullet || isHeading) {
-        if (currentBlock.length > 0) {
-          entries.push(currentBlock.join("\n"));
+    const stats = fs4.statSync(learningsPath);
+    const cacheKey = learningsPath;
+    const cached = learningsCacheMap.get(cacheKey);
+    let entries;
+    if (cached && cached.mtimeMs === stats.mtimeMs) {
+      entries = cached.entries;
+    } else {
+      const content = fs4.readFileSync(learningsPath, "utf-8");
+      const lines = content.split("\n");
+      entries = [];
+      let currentBlock = [];
+      for (const line of lines) {
+        if (line.startsWith("# ")) continue;
+        const isDatedBullet = /^- \*\*\d{4}-\d{2}-\d{2}/.test(line);
+        const isHeading = /^## \d{4}-\d{2}-\d{2}/.test(line);
+        if (isDatedBullet || isHeading) {
+          if (currentBlock.length > 0) {
+            entries.push(currentBlock.join("\n"));
+          }
+          currentBlock = [line];
+        } else if (line.trim() !== "" && currentBlock.length > 0) {
+          currentBlock.push(line);
         }
-        currentBlock = [line];
-      } else if (line.trim() !== "" && currentBlock.length > 0) {
-        currentBlock.push(line);
       }
-    }
-    if (currentBlock.length > 0) {
-      entries.push(currentBlock.join("\n"));
+      if (currentBlock.length > 0) {
+        entries.push(currentBlock.join("\n"));
+      }
+      learningsCacheMap.set(cacheKey, { mtimeMs: stats.mtimeMs, entries });
+      evictIfNeeded(learningsCacheMap);
     }
     if (!skillName) {
       return Ok(entries);
@@ -5135,6 +5154,12 @@ async function loadFailures(projectPath, stream) {
     if (!fs4.existsSync(failuresPath)) {
       return Ok([]);
     }
+    const stats = fs4.statSync(failuresPath);
+    const cacheKey = failuresPath;
+    const cached = failuresCacheMap.get(cacheKey);
+    if (cached && cached.mtimeMs === stats.mtimeMs) {
+      return Ok(cached.entries);
+    }
     const content = fs4.readFileSync(failuresPath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
@@ -5148,6 +5173,8 @@ async function loadFailures(projectPath, stream) {
         });
       }
     }
+    failuresCacheMap.set(cacheKey, { mtimeMs: stats.mtimeMs, entries });
+    evictIfNeeded(failuresCacheMap);
     return Ok(entries);
   } catch (error) {
     return Err(
@@ -6199,14 +6226,22 @@ async function runCIChecks(input) {
   const { projectRoot, config, skip = [], failOn = "error" } = input;
   try {
     const checks = [];
-    for (const name of ALL_CHECKS) {
-      if (skip.includes(name)) {
-        checks.push({ name, status: "skip", issues: [], durationMs: 0 });
-      } else {
-        const result = await runSingleCheck(name, projectRoot, config);
-        checks.push(result);
-      }
+    const skippedSet = new Set(skip);
+    if (skippedSet.has("validate")) {
+      checks.push({ name: "validate", status: "skip", issues: [], durationMs: 0 });
+    } else {
+      checks.push(await runSingleCheck("validate", projectRoot, config));
     }
+    const remainingChecks = ALL_CHECKS.slice(1);
+    const phase2Results = await Promise.all(
+      remainingChecks.map(async (name) => {
+        if (skippedSet.has(name)) {
+          return { name, status: "skip", issues: [], durationMs: 0 };
+        }
+        return runSingleCheck(name, projectRoot, config);
+      })
+    );
+    checks.push(...phase2Results);
     const summary = buildSummary(checks);
     const exitCode = determineExitCode(summary, failOn);
     const report = {
@@ -6328,76 +6363,93 @@ async function runMechanicalChecks(options) {
       });
     }
   }
+  const parallelChecks = [];
   if (!skip.includes("check-docs")) {
-    try {
-      const docsDir = path6.join(projectRoot, config.docsDir ?? "docs");
-      const result = await checkDocCoverage("project", { docsDir });
-      if (!result.ok) {
-        statuses["check-docs"] = "warn";
-        findings.push({
-          tool: "check-docs",
-          file: docsDir,
-          message: result.error.message,
-          severity: "warning"
-        });
-      } else if (result.value.gaps && result.value.gaps.length > 0) {
-        statuses["check-docs"] = "warn";
-        for (const gap of result.value.gaps) {
-          findings.push({
+    parallelChecks.push(
+      (async () => {
+        const localFindings = [];
+        try {
+          const docsDir = path6.join(projectRoot, config.docsDir ?? "docs");
+          const result = await checkDocCoverage("project", { docsDir });
+          if (!result.ok) {
+            statuses["check-docs"] = "warn";
+            localFindings.push({
+              tool: "check-docs",
+              file: docsDir,
+              message: result.error.message,
+              severity: "warning"
+            });
+          } else if (result.value.gaps && result.value.gaps.length > 0) {
+            statuses["check-docs"] = "warn";
+            for (const gap of result.value.gaps) {
+              localFindings.push({
+                tool: "check-docs",
+                file: gap.file,
+                message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
+                severity: "warning"
+              });
+            }
+          } else {
+            statuses["check-docs"] = "pass";
+          }
+        } catch (err) {
+          statuses["check-docs"] = "warn";
+          localFindings.push({
             tool: "check-docs",
-            file: gap.file,
-            message: `Undocumented: ${gap.file} (suggested: ${gap.suggestedSection})`,
+            file: path6.join(projectRoot, "docs"),
+            message: err instanceof Error ? err.message : String(err),
             severity: "warning"
           });
         }
-      } else {
-        statuses["check-docs"] = "pass";
-      }
-    } catch (err) {
-      statuses["check-docs"] = "warn";
-      findings.push({
-        tool: "check-docs",
-        file: path6.join(projectRoot, "docs"),
-        message: err instanceof Error ? err.message : String(err),
-        severity: "warning"
-      });
-    }
+        return localFindings;
+      })()
+    );
   }
   if (!skip.includes("security-scan")) {
-    try {
-      const securityConfig = parseSecurityConfig(config.security);
-      if (!securityConfig.enabled) {
-        statuses["security-scan"] = "skip";
-      } else {
-        const scanner = new SecurityScanner(securityConfig);
-        scanner.configureForProject(projectRoot);
-        const filesToScan = changedFiles ?? [];
-        const scanResult = await scanner.scanFiles(filesToScan);
-        if (scanResult.findings.length > 0) {
-          statuses["security-scan"] = "warn";
-          for (const f of scanResult.findings) {
-            findings.push({
-              tool: "security-scan",
-              file: f.file,
-              line: f.line,
-              ruleId: f.ruleId,
-              message: f.message,
-              severity: f.severity === "info" ? "warning" : f.severity
-            });
+    parallelChecks.push(
+      (async () => {
+        const localFindings = [];
+        try {
+          const securityConfig = parseSecurityConfig(config.security);
+          if (!securityConfig.enabled) {
+            statuses["security-scan"] = "skip";
+          } else {
+            const scanner = new SecurityScanner(securityConfig);
+            scanner.configureForProject(projectRoot);
+            const filesToScan = changedFiles ?? [];
+            const scanResult = await scanner.scanFiles(filesToScan);
+            if (scanResult.findings.length > 0) {
+              statuses["security-scan"] = "warn";
+              for (const f of scanResult.findings) {
+                localFindings.push({
+                  tool: "security-scan",
+                  file: f.file,
+                  line: f.line,
+                  ruleId: f.ruleId,
+                  message: f.message,
+                  severity: f.severity === "info" ? "warning" : f.severity
+                });
+              }
+            } else {
+              statuses["security-scan"] = "pass";
+            }
           }
-        } else {
-          statuses["security-scan"] = "pass";
+        } catch (err) {
+          statuses["security-scan"] = "warn";
+          localFindings.push({
+            tool: "security-scan",
+            file: projectRoot,
+            message: err instanceof Error ? err.message : String(err),
+            severity: "warning"
+          });
         }
-      }
-    } catch (err) {
-      statuses["security-scan"] = "warn";
-      findings.push({
-        tool: "security-scan",
-        file: projectRoot,
-        message: err instanceof Error ? err.message : String(err),
-        severity: "warning"
-      });
-    }
+        return localFindings;
+      })()
+    );
+  }
+  const parallelResults = await Promise.all(parallelChecks);
+  for (const result of parallelResults) {
+    findings.push(...result);
   }
   const hasErrors = findings.some((f) => f.severity === "error");
   const stopPipeline = statuses.validate === "fail" || statuses["check-deps"] === "fail";

package/dist/{chunk-Y7U5AYAL.js → chunk-RTPHUDZS.js}

@@ -31,7 +31,7 @@ import {
   validateAgentsMap,
   validateDependencies,
   validateKnowledgeMap
-} from "./chunk-SAB3VXOW.js";
+} from "./chunk-CGSHUJES.js";
 import {
   CLIError,
   ExitCode,
@@ -369,7 +369,7 @@ function createValidateCommand() {
       process.exit(result.error.exitCode);
     }
     if (opts.crossCheck) {
-      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-DLNK423G.js");
+      const { runCrossCheck: runCrossCheck2 } = await import("./validate-cross-check-VG573VZO.js");
       const cwd = process.cwd();
       const specsDir = path2.join(cwd, "docs", "specs");
       const plansDir = path2.join(cwd, "docs", "plans");
@@ -735,7 +735,7 @@ function createPerfCommand() {
   perf.command("bench [glob]").description("Run benchmarks via vitest bench").action(async (glob2, _opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-ZODQVGC4.js");
+    const { BenchmarkRunner } = await import("./dist-C5PYIQPF.js");
     const runner = new BenchmarkRunner();
     const benchFiles = runner.discover(cwd, glob2);
     if (benchFiles.length === 0) {
@@ -804,7 +804,7 @@ Results (${result.results.length} benchmarks):`);
   baselines.command("update").description("Update baselines from latest benchmark run").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { BenchmarkRunner } = await import("./dist-ZODQVGC4.js");
+    const { BenchmarkRunner } = await import("./dist-C5PYIQPF.js");
     const runner = new BenchmarkRunner();
     const manager = new BaselineManager(cwd);
     logger.info("Running benchmarks to update baselines...");
@@ -832,7 +832,7 @@ Results (${result.results.length} benchmarks):`);
   perf.command("report").description("Full performance report with metrics, trends, and hotspots").action(async (_opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const cwd = process.cwd();
-    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-ZODQVGC4.js");
+    const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./dist-C5PYIQPF.js");
     const analyzer = new EntropyAnalyzer2({
       rootDir: path6.resolve(cwd),
       analyze: { complexity: true, coupling: true }
@@ -5094,7 +5094,7 @@ function createGenerateCommand3() {
 import { Command as Command39 } from "commander";
 import * as path37 from "path";
 async function runScan(projectPath) {
-  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-I7DB5VKB.js");
   const store = new GraphStore();
   const start = Date.now();
   await new CodeIngestor(store).ingest(projectPath);
@@ -5175,7 +5175,7 @@ async function runIngest(projectPath, source, opts) {
     SyncManager,
     JiraConnector,
     SlackConnector
-  } = await import("./dist-K6KTTN3I.js");
+  } = await import("./dist-I7DB5VKB.js");
   const graphDir = path38.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   await store.load(graphDir);
@@ -5268,7 +5268,7 @@ function createIngestCommand() {
 import { Command as Command41 } from "commander";
 import * as path39 from "path";
 async function runQuery(projectPath, rootNodeId, opts) {
-  const { GraphStore, ContextQL } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore, ContextQL } = await import("./dist-I7DB5VKB.js");
   const store = new GraphStore();
   const graphDir = path39.join(projectPath, ".harness", "graph");
   const loaded = await store.load(graphDir);
@@ -5317,7 +5317,7 @@ import { Command as Command42 } from "commander";
 // src/commands/graph/status.ts
 import * as path40 from "path";
 async function runGraphStatus(projectPath) {
-  const { GraphStore } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore } = await import("./dist-I7DB5VKB.js");
   const graphDir = path40.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);
@@ -5357,7 +5357,7 @@ async function runGraphStatus(projectPath) {
 // src/commands/graph/export.ts
 import * as path41 from "path";
 async function runGraphExport(projectPath, format) {
-  const { GraphStore } = await import("./dist-K6KTTN3I.js");
+  const { GraphStore } = await import("./dist-I7DB5VKB.js");
   const graphDir = path41.join(projectPath, ".harness", "graph");
   const store = new GraphStore();
   const loaded = await store.load(graphDir);

package/dist/{dist-ZODQVGC4.js → dist-C5PYIQPF.js}

@@ -165,7 +165,7 @@ import {
   validateKnowledgeMap,
   validatePatternConfig,
   xssRules
-} from "./chunk-SAB3VXOW.js";
+} from "./chunk-CGSHUJES.js";
 export {
   AGENT_DESCRIPTORS,
   ARCHITECTURE_DESCRIPTOR,

package/dist/{dist-K6KTTN3I.js → dist-I7DB5VKB.js}

@@ -2164,6 +2164,242 @@ var GraphCouplingAdapter = class {
     return maxDepth;
   }
 };
+var DEFAULT_THRESHOLD = 2;
+var DEFAULT_METRICS = [
+  "cyclomaticComplexity",
+  "fanIn",
+  "fanOut",
+  "hotspotScore",
+  "transitiveDepth"
+];
+var RECOGNIZED_METRICS = new Set(DEFAULT_METRICS);
+var GraphAnomalyAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  detect(options) {
+    const threshold = options?.threshold != null && options.threshold > 0 ? options.threshold : DEFAULT_THRESHOLD;
+    const requestedMetrics = options?.metrics ?? [...DEFAULT_METRICS];
+    const warnings = [];
+    const metricsToAnalyze = [];
+    for (const m of requestedMetrics) {
+      if (RECOGNIZED_METRICS.has(m)) {
+        metricsToAnalyze.push(m);
+      } else {
+        warnings.push(m);
+      }
+    }
+    const allOutliers = [];
+    const analyzedNodeIds = /* @__PURE__ */ new Set();
+    const couplingMetrics = ["fanIn", "fanOut", "transitiveDepth"];
+    const needsCoupling = metricsToAnalyze.some((m) => couplingMetrics.includes(m));
+    const needsComplexity = metricsToAnalyze.includes("hotspotScore");
+    const cachedCouplingData = needsCoupling ? new GraphCouplingAdapter(this.store).computeCouplingData() : void 0;
+    const cachedHotspotData = needsComplexity ? new GraphComplexityAdapter(this.store).computeComplexityHotspots() : void 0;
+    for (const metric of metricsToAnalyze) {
+      const entries = this.collectMetricValues(metric, cachedCouplingData, cachedHotspotData);
+      for (const e of entries) {
+        analyzedNodeIds.add(e.nodeId);
+      }
+      const outliers = this.computeZScoreOutliers(entries, metric, threshold);
+      allOutliers.push(...outliers);
+    }
+    allOutliers.sort((a, b) => b.zScore - a.zScore);
+    const articulationPoints = this.findArticulationPoints();
+    const outlierNodeIds = new Set(allOutliers.map((o) => o.nodeId));
+    const apNodeIds = new Set(articulationPoints.map((ap) => ap.nodeId));
+    const overlapping = [...outlierNodeIds].filter((id) => apNodeIds.has(id));
+    return {
+      statisticalOutliers: allOutliers,
+      articulationPoints,
+      overlapping,
+      summary: {
+        totalNodesAnalyzed: analyzedNodeIds.size,
+        outlierCount: allOutliers.length,
+        articulationPointCount: articulationPoints.length,
+        overlapCount: overlapping.length,
+        metricsAnalyzed: metricsToAnalyze,
+        warnings,
+        threshold
+      }
+    };
+  }
+  collectMetricValues(metric, cachedCouplingData, cachedHotspotData) {
+    const entries = [];
+    if (metric === "cyclomaticComplexity") {
+      const functionNodes = [
+        ...this.store.findNodes({ type: "function" }),
+        ...this.store.findNodes({ type: "method" })
+      ];
+      for (const node of functionNodes) {
+        const cc = node.metadata?.cyclomaticComplexity;
+        if (typeof cc === "number") {
+          entries.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            nodePath: node.path,
+            nodeType: node.type,
+            value: cc
+          });
+        }
+      }
+    } else if (metric === "fanIn" || metric === "fanOut" || metric === "transitiveDepth") {
+      const couplingData = cachedCouplingData ?? new GraphCouplingAdapter(this.store).computeCouplingData();
+      const fileNodes = this.store.findNodes({ type: "file" });
+      for (const fileData of couplingData.files) {
+        const fileNode = fileNodes.find((n) => (n.path ?? n.name) === fileData.file);
+        if (!fileNode) continue;
+        entries.push({
+          nodeId: fileNode.id,
+          nodeName: fileNode.name,
+          nodePath: fileNode.path,
+          nodeType: "file",
+          value: fileData[metric]
+        });
+      }
+    } else if (metric === "hotspotScore") {
+      const hotspots = cachedHotspotData ?? new GraphComplexityAdapter(this.store).computeComplexityHotspots();
+      const functionNodes = [
+        ...this.store.findNodes({ type: "function" }),
+        ...this.store.findNodes({ type: "method" })
+      ];
+      for (const h of hotspots.hotspots) {
+        const fnNode = functionNodes.find(
+          (n) => n.name === h.function && (n.path ?? "") === (h.file ?? "")
+        );
+        if (!fnNode) continue;
+        entries.push({
+          nodeId: fnNode.id,
+          nodeName: fnNode.name,
+          nodePath: fnNode.path,
+          nodeType: fnNode.type,
+          value: h.hotspotScore
+        });
+      }
+    }
+    return entries;
+  }
+  computeZScoreOutliers(entries, metric, threshold) {
+    if (entries.length === 0) return [];
+    const values = entries.map((e) => e.value);
+    const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+    const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+    const stdDev = Math.sqrt(variance);
+    if (stdDev === 0) return [];
+    const outliers = [];
+    for (const entry of entries) {
+      const zScore = Math.abs(entry.value - mean) / stdDev;
+      if (zScore > threshold) {
+        outliers.push({
+          nodeId: entry.nodeId,
+          nodeName: entry.nodeName,
+          nodePath: entry.nodePath,
+          nodeType: entry.nodeType,
+          metric,
+          value: entry.value,
+          zScore,
+          mean,
+          stdDev
+        });
+      }
+    }
+    return outliers;
+  }
+  findArticulationPoints() {
+    const fileNodes = this.store.findNodes({ type: "file" });
+    if (fileNodes.length === 0) return [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    const adj = /* @__PURE__ */ new Map();
+    for (const node of fileNodes) {
+      nodeMap.set(node.id, { name: node.name, path: node.path });
+      adj.set(node.id, /* @__PURE__ */ new Set());
+    }
+    const importEdges = this.store.getEdges({ type: "imports" });
+    for (const edge of importEdges) {
+      if (adj.has(edge.from) && adj.has(edge.to)) {
+        adj.get(edge.from).add(edge.to);
+        adj.get(edge.to).add(edge.from);
+      }
+    }
+    const disc = /* @__PURE__ */ new Map();
+    const low = /* @__PURE__ */ new Map();
+    const parent = /* @__PURE__ */ new Map();
+    const apSet = /* @__PURE__ */ new Set();
+    let timer = 0;
+    const dfs = (u) => {
+      disc.set(u, timer);
+      low.set(u, timer);
+      timer++;
+      let children = 0;
+      for (const v of adj.get(u)) {
+        if (!disc.has(v)) {
+          children++;
+          parent.set(v, u);
+          dfs(v);
+          low.set(u, Math.min(low.get(u), low.get(v)));
+          if (parent.get(u) === null && children > 1) {
+            apSet.add(u);
+          }
+          if (parent.get(u) !== null && low.get(v) >= disc.get(u)) {
+            apSet.add(u);
+          }
+        } else if (v !== parent.get(u)) {
+          low.set(u, Math.min(low.get(u), disc.get(v)));
+        }
+      }
+    };
+    for (const nodeId of adj.keys()) {
+      if (!disc.has(nodeId)) {
+        parent.set(nodeId, null);
+        dfs(nodeId);
+      }
+    }
+    const results = [];
+    for (const apId of apSet) {
+      const { components, dependentCount } = this.computeRemovalImpact(apId, adj);
+      const info = nodeMap.get(apId);
+      results.push({
+        nodeId: apId,
+        nodeName: info.name,
+        nodePath: info.path,
+        componentsIfRemoved: components,
+        dependentCount
+      });
+    }
+    results.sort((a, b) => b.dependentCount - a.dependentCount);
+    return results;
+  }
+  computeRemovalImpact(removedId, adj) {
+    const visited = /* @__PURE__ */ new Set();
+    visited.add(removedId);
+    const componentSizes = [];
+    for (const nodeId of adj.keys()) {
+      if (visited.has(nodeId)) continue;
+      const queue = [nodeId];
+      visited.add(nodeId);
+      let size = 0;
+      let head = 0;
+      while (head < queue.length) {
+        const current = queue[head++];
+        size++;
+        for (const neighbor of adj.get(current)) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      componentSizes.push(size);
+    }
+    const components = componentSizes.length;
+    if (componentSizes.length <= 1) {
+      return { components, dependentCount: 0 };
+    }
+    const maxSize = Math.max(...componentSizes);
+    const dependentCount = componentSizes.reduce((sum, s) => sum + s, 0) - maxSize;
+    return { components, dependentCount };
+  }
+};
 var PHASE_NODE_TYPES = {
   implement: ["file", "function", "class", "method", "interface", "variable"],
   review: ["adr", "document", "learning", "commit"],
@@ -2785,6 +3021,7 @@ export {
   EDGE_TYPES,
   FusionLayer,
   GitIngestor,
+  GraphAnomalyAdapter,
   GraphComplexityAdapter,
   GraphConstraintAdapter,
   GraphCouplingAdapter,

package/dist/index.js

@@ -30,11 +30,11 @@ import {
   runPersona,
   runQuery,
   runScan
-} from "./chunk-Y7U5AYAL.js";
+} from "./chunk-RTPHUDZS.js";
 import {
   runCrossCheck
-} from "./chunk-LB4GRDDV.js";
-import "./chunk-SAB3VXOW.js";
+} from "./chunk-6JIT7CEM.js";
+import "./chunk-CGSHUJES.js";
 import {
   CLIError,
   ExitCode,

package/dist/validate-cross-check-VG573VZO.js

@@ -0,0 +1,7 @@
+import {
+  runCrossCheck
+} from "./chunk-6JIT7CEM.js";
+import "./chunk-CGSHUJES.js";
+export {
+  runCrossCheck
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/cli",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "CLI for Harness Engineering toolkit",
   "type": "module",
   "bin": {
@@ -30,9 +30,9 @@
     "minimatch": "^10.2.4",
     "yaml": "^2.3.0",
     "zod": "^3.22.0",
-    "@harness-engineering/core": "0.9.2",
-    "@harness-engineering/linter-gen": "0.1.2",
-    "@harness-engineering/graph": "0.2.3"
+    "@harness-engineering/core": "0.10.0",
+    "@harness-engineering/graph": "0.3.0",
+    "@harness-engineering/linter-gen": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",