@harness-engineering/core 0.26.4 → 0.28.0

package/dist/chunk-FYTJQ2ZY.mjs

@@ -0,0 +1,1171 @@
+import {
+  Ok,
+  buildDependencyGraph,
+  detectComplexityViolations,
+  detectCouplingViolations,
+  findFiles,
+  getDefaultRegistry,
+  relativePosix,
+  validateDependencies
+} from "./chunk-MUWJHO2S.mjs";
+import {
+  ArchBaselineSchema,
+  ArchConfigSchema
+} from "./chunk-IIEDD47I.mjs";
+
+// src/architecture/collectors/hash.ts
+import { createHash } from "crypto";
+function violationId(relativePath, category, normalizedDetail) {
+  const input = `${relativePath}:${category}:${normalizedDetail}`;
+  return createHash("sha256").update(input).digest("hex");
+}
+function constraintRuleId(category, scope, description) {
+  const input = `${category}:${scope}:${description}`;
+  return createHash("sha256").update(input).digest("hex");
+}
+
+// src/constraints/circular-deps.ts
+function buildAdjacencyList(graph) {
+  const adjacency = /* @__PURE__ */ new Map();
+  const nodeSet = new Set(graph.nodes);
+  for (const node of graph.nodes) {
+    adjacency.set(node, []);
+  }
+  for (const edge of graph.edges) {
+    const neighbors = adjacency.get(edge.from);
+    if (neighbors && nodeSet.has(edge.to)) {
+      neighbors.push(edge.to);
+    }
+  }
+  return adjacency;
+}
+function isCyclicSCC(scc, adjacency) {
+  if (scc.length > 1) return true;
+  if (scc.length === 1) {
+    const selfNode = scc[0];
+    const selfNeighbors = adjacency.get(selfNode) ?? [];
+    return selfNeighbors.includes(selfNode);
+  }
+  return false;
+}
+function processNeighbors(node, neighbors, nodeMap, stack, adjacency, sccs, indexRef) {
+  for (const neighbor of neighbors) {
+    const neighborData = nodeMap.get(neighbor);
+    if (!neighborData) {
+      strongConnectImpl(neighbor, nodeMap, stack, adjacency, sccs, indexRef);
+      const nodeData = nodeMap.get(node);
+      const updatedNeighborData = nodeMap.get(neighbor);
+      nodeData.lowlink = Math.min(nodeData.lowlink, updatedNeighborData.lowlink);
+    } else if (neighborData.onStack) {
+      const nodeData = nodeMap.get(node);
+      nodeData.lowlink = Math.min(nodeData.lowlink, neighborData.index);
+    }
+  }
+}
+function strongConnectImpl(node, nodeMap, stack, adjacency, sccs, indexRef) {
+  nodeMap.set(node, { index: indexRef.value, lowlink: indexRef.value, onStack: true });
+  indexRef.value++;
+  stack.push(node);
+  processNeighbors(node, adjacency.get(node) ?? [], nodeMap, stack, adjacency, sccs, indexRef);
+  const nodeData = nodeMap.get(node);
+  if (nodeData.lowlink === nodeData.index) {
+    const scc = [];
+    let w;
+    do {
+      w = stack.pop();
+      nodeMap.get(w).onStack = false;
+      scc.push(w);
+    } while (w !== node);
+    if (isCyclicSCC(scc, adjacency)) {
+      sccs.push(scc);
+    }
+  }
+}
+function tarjanSCC(graph) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const stack = [];
+  const sccs = [];
+  const indexRef = { value: 0 };
+  const adjacency = buildAdjacencyList(graph);
+  for (const node of graph.nodes) {
+    if (!nodeMap.has(node)) {
+      strongConnectImpl(node, nodeMap, stack, adjacency, sccs, indexRef);
+    }
+  }
+  return sccs;
+}
+function detectCircularDeps(graph) {
+  const sccs = tarjanSCC(graph);
+  const cycles = sccs.map((scc) => {
+    const reversed = scc.reverse();
+    const firstNode = reversed[reversed.length - 1];
+    const cycle = [...reversed, firstNode];
+    return {
+      cycle,
+      severity: "error",
+      size: scc.length
+    };
+  });
+  const largestCycle = cycles.reduce((max, c) => Math.max(max, c.size), 0);
+  return Ok({
+    hasCycles: cycles.length > 0,
+    cycles,
+    largestCycle
+  });
+}
+async function detectCircularDepsInFiles(files, parser, graphDependencyData) {
+  const graphResult = await buildDependencyGraph(files, parser, graphDependencyData);
+  if (!graphResult.ok) {
+    return graphResult;
+  }
+  return detectCircularDeps(graphResult.value);
+}
+
+// src/architecture/collectors/circular-deps.ts
+function makeStubParser() {
+  return {
+    name: "typescript",
+    extensions: [".ts", ".tsx"],
+    parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "not needed" } }),
+    extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "not needed" } }),
+    extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "not needed" } }),
+    health: async () => ({ ok: true, value: { available: true } })
+  };
+}
+function mapCycleViolations(cycles, rootDir, category) {
+  return cycles.map((cycle) => {
+    const cyclePath = cycle.cycle.map((f) => relativePosix(rootDir, f)).join(" -> ");
+    const firstFile = relativePosix(rootDir, cycle.cycle[0]);
+    return {
+      id: violationId(firstFile, category, cyclePath),
+      file: firstFile,
+      detail: `Circular dependency: ${cyclePath}`,
+      severity: cycle.severity
+    };
+  });
+}
+var CircularDepsCollector = class {
+  category = "circular-deps";
+  getRules(_config, _rootDir) {
+    const description = "No circular dependencies allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const graphResult = await buildDependencyGraph(files, makeStubParser());
+    if (!graphResult.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to build dependency graph" }
+        }
+      ];
+    }
+    const result = detectCircularDeps(graphResult.value);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect circular deps" }
+        }
+      ];
+    }
+    const { cycles, largestCycle } = result.value;
+    const violations = mapCycleViolations(cycles, rootDir, this.category);
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: cycles.length,
+        violations,
+        metadata: { largestCycle, cycleCount: cycles.length }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/layer-violations.ts
+function mapLayerViolations(layerViolations, rootDir, category) {
+  return layerViolations.map((v) => {
+    const relFile = relativePosix(rootDir, v.file);
+    const relImport = relativePosix(rootDir, v.imports);
+    const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
+    return {
+      id: violationId(relFile, category ?? "", detail),
+      file: relFile,
+      category,
+      detail,
+      severity: "error"
+    };
+  });
+}
+var LayerViolationCollector = class {
+  category = "layer-violations";
+  getRules(_config, _rootDir) {
+    const description = "No layer boundary violations allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const registry = getDefaultRegistry();
+    const parser = registry.getByLanguage("typescript") ?? registry.getByLanguage("javascript");
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const violations = mapLayerViolations(
+      result.value.violations.filter((v) => v.reason === "WRONG_LAYER"),
+      rootDir,
+      this.category
+    );
+    return [{ category: this.category, scope: "project", value: violations.length, violations }];
+  }
+};
+
+// src/architecture/baseline-manager.ts
+import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from "fs";
+import { randomBytes } from "crypto";
+import { join, dirname } from "path";
+var ArchBaselineManager = class {
+  baselinesPath;
+  constructor(projectRoot, baselinePath) {
+    this.baselinesPath = baselinePath ? join(projectRoot, baselinePath) : join(projectRoot, ".harness", "arch", "baselines.json");
+  }
+  /**
+   * Snapshot the current metric results into an ArchBaseline.
+   * Aggregates multiple MetricResults for the same category by summing values
+   * and concatenating violation IDs.
+   */
+  capture(results, commitHash) {
+    const metrics = {};
+    for (const result of results) {
+      const existing = metrics[result.category];
+      if (existing) {
+        existing.value += result.value;
+        existing.violationIds.push(...result.violations.map((v) => v.id));
+      } else {
+        metrics[result.category] = {
+          value: result.value,
+          violationIds: result.violations.map((v) => v.id)
+        };
+      }
+    }
+    for (const baseline of Object.values(metrics)) {
+      baseline.violationIds = [...new Set(baseline.violationIds)];
+    }
+    return {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedFrom: commitHash,
+      metrics
+    };
+  }
+  /**
+   * Load the baselines file from disk.
+   * Returns null if the file does not exist, contains invalid JSON,
+   * or fails ArchBaselineSchema validation.
+   */
+  load() {
+    if (!existsSync(this.baselinesPath)) {
+      console.error(`Baseline file not found at: ${this.baselinesPath}`);
+      return null;
+    }
+    try {
+      const raw = readFileSync(this.baselinesPath, "utf-8");
+      const data = JSON.parse(raw);
+      const parsed = ArchBaselineSchema.safeParse(data);
+      if (!parsed.success) {
+        console.error(
+          `Baseline validation failed for ${this.baselinesPath}:`,
+          parsed.error.format()
+        );
+        return null;
+      }
+      return parsed.data;
+    } catch (error) {
+      console.error(`Error loading baseline from ${this.baselinesPath}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Refresh the on-disk baseline with new results.
+   *
+   * Categories present in `results` overwrite their on-disk entry; categories
+   * absent from `results` are preserved as-is. This prevents silent data loss
+   * when a collector returns no results (e.g. transient failure or a filtered
+   * run) and the regenerated file is committed (issue #268).
+   *
+   * Use this from the `--update-baseline` flow instead of `capture()` + `save()`.
+   */
+  update(results, commitHash) {
+    const fresh = this.capture(results, commitHash);
+    const existing = this.load();
+    if (existing) {
+      fresh.metrics = { ...existing.metrics, ...fresh.metrics };
+    }
+    this.save(fresh);
+    return fresh;
+  }
+  /**
+   * Save an ArchBaseline to disk.
+   * Creates parent directories if they do not exist.
+   * Uses atomic write (write to temp file, then rename) to prevent corruption.
+   */
+  save(baseline) {
+    const dir = dirname(this.baselinesPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    const tmp = this.baselinesPath + "." + randomBytes(4).toString("hex") + ".tmp";
+    writeFileSync(tmp, JSON.stringify(baseline, null, 2));
+    renameSync(tmp, this.baselinesPath);
+  }
+};
+
+// src/architecture/diff.ts
+function aggregateByCategory(results) {
+  const map = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = map.get(result.category);
+    if (existing) {
+      existing.value += result.value;
+      existing.violations.push(...result.violations);
+    } else {
+      map.set(result.category, {
+        value: result.value,
+        violations: [...result.violations]
+      });
+    }
+  }
+  return map;
+}
+function classifyViolations(violations, baselineViolationIds) {
+  const newViolations = [];
+  const preExisting = [];
+  for (const violation of violations) {
+    if (baselineViolationIds.has(violation.id)) {
+      preExisting.push(violation.id);
+    } else {
+      newViolations.push(violation);
+    }
+  }
+  return { newViolations, preExisting };
+}
+function findResolvedViolations(baselineCategory, currentViolationIds) {
+  if (!baselineCategory) return [];
+  return baselineCategory.violationIds.filter((id) => !currentViolationIds.has(id));
+}
+function collectOrphanedBaselineViolations(baseline, visitedCategories) {
+  const resolved = [];
+  for (const [category, baselineCategory] of Object.entries(baseline.metrics)) {
+    if (!visitedCategories.has(category) && baselineCategory) {
+      resolved.push(...baselineCategory.violationIds);
+    }
+  }
+  return resolved;
+}
+function diffCategory(category, agg, baselineCategory, acc) {
+  const baselineViolationIds = new Set(baselineCategory?.violationIds ?? []);
+  const baselineValue = baselineCategory?.value ?? 0;
+  const classified = classifyViolations(agg.violations, baselineViolationIds);
+  acc.newViolations.push(...classified.newViolations);
+  acc.preExisting.push(...classified.preExisting);
+  const currentViolationIds = new Set(agg.violations.map((v) => v.id));
+  acc.resolvedViolations.push(...findResolvedViolations(baselineCategory, currentViolationIds));
+  if (baselineCategory && agg.value > baselineValue) {
+    acc.regressions.push({
+      category,
+      baselineValue,
+      currentValue: agg.value,
+      delta: agg.value - baselineValue
+    });
+  }
+}
+function diff(current, baseline) {
+  const aggregated = aggregateByCategory(current);
+  const acc = {
+    newViolations: [],
+    resolvedViolations: [],
+    preExisting: [],
+    regressions: []
+  };
+  const visitedCategories = /* @__PURE__ */ new Set();
+  for (const [category, agg] of aggregated) {
+    visitedCategories.add(category);
+    diffCategory(category, agg, baseline.metrics[category], acc);
+  }
+  acc.resolvedViolations.push(...collectOrphanedBaselineViolations(baseline, visitedCategories));
+  return {
+    passed: acc.newViolations.length === 0 && acc.regressions.length === 0,
+    newViolations: acc.newViolations,
+    resolvedViolations: acc.resolvedViolations,
+    preExisting: acc.preExisting,
+    regressions: acc.regressions
+  };
+}
+
+// src/architecture/collectors/complexity.ts
+function buildSnapshot(files, rootDir) {
+  return {
+    files: files.map((f) => ({
+      path: f,
+      ast: { type: "Program", body: null, language: "typescript" },
+      imports: [],
+      exports: [],
+      internalSymbols: [],
+      jsDocComments: []
+    })),
+    dependencyGraph: { nodes: [], edges: [] },
+    exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+    docs: [],
+    codeReferences: [],
+    entryPoints: [],
+    rootDir,
+    config: { rootDir, analyze: {} },
+    buildTime: 0
+  };
+}
+function resolveMaxComplexity(config) {
+  const threshold = config.thresholds.complexity;
+  return typeof threshold === "number" ? threshold : threshold?.max ?? 15;
+}
+function mapComplexityViolations(complexityViolations, rootDir, category) {
+  return complexityViolations.filter((v) => v.severity === "error" || v.severity === "warning").map((v) => {
+    const relFile = relativePosix(rootDir, v.file);
+    return {
+      id: violationId(relFile, category ?? "", `${v.metric}:${v.function}`),
+      file: relFile,
+      category,
+      detail: `${v.metric}=${v.value} in ${v.function} (threshold: ${v.threshold})`,
+      severity: v.severity
+    };
+  });
+}
+var ComplexityCollector = class {
+  category = "complexity";
+  getRules(_config, _rootDir) {
+    const description = "Cyclomatic complexity must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const snapshot = buildSnapshot(files, rootDir);
+    const maxComplexity = resolveMaxComplexity(_config);
+    const complexityConfig = {
+      thresholds: {
+        cyclomaticComplexity: { error: maxComplexity, warn: Math.floor(maxComplexity * 0.7) }
+      }
+    };
+    const result = await detectComplexityViolations(snapshot, complexityConfig);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect complexity violations" }
+        }
+      ];
+    }
+    const { violations: complexityViolations, stats } = result.value;
+    const violations = mapComplexityViolations(complexityViolations, rootDir, this.category);
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: {
+          filesAnalyzed: stats.filesAnalyzed,
+          functionsAnalyzed: stats.functionsAnalyzed
+        }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/coupling.ts
+function buildCouplingSnapshot(files, rootDir) {
+  return {
+    files: files.map((f) => ({
+      path: f,
+      ast: { type: "Program", body: null, language: "typescript" },
+      imports: [],
+      exports: [],
+      internalSymbols: [],
+      jsDocComments: []
+    })),
+    dependencyGraph: { nodes: [], edges: [] },
+    exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+    docs: [],
+    codeReferences: [],
+    entryPoints: [],
+    rootDir,
+    config: { rootDir, analyze: {} },
+    buildTime: 0
+  };
+}
+function mapCouplingViolations(couplingViolations, rootDir, category) {
+  return couplingViolations.filter((v) => v.severity === "error" || v.severity === "warning").map((v) => {
+    const relFile = relativePosix(rootDir, v.file);
+    return {
+      id: violationId(relFile, category ?? "", v.metric),
+      file: relFile,
+      category,
+      detail: `${v.metric}=${v.value} (threshold: ${v.threshold})`,
+      severity: v.severity
+    };
+  });
+}
+var CouplingCollector = class {
+  category = "coupling";
+  getRules(_config, _rootDir) {
+    const description = "Coupling metrics must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const files = await findFiles("**/*.ts", rootDir);
+    const snapshot = buildCouplingSnapshot(files, rootDir);
+    const result = await detectCouplingViolations(snapshot);
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to detect coupling violations" }
+        }
+      ];
+    }
+    const { violations: couplingViolations, stats } = result.value;
+    const violations = mapCouplingViolations(couplingViolations, rootDir, this.category);
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: { filesAnalyzed: stats.filesAnalyzed }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/forbidden-imports.ts
+function mapForbiddenImportViolations(forbidden, rootDir, category) {
+  return forbidden.map((v) => {
+    const relFile = relativePosix(rootDir, v.file);
+    const relImport = relativePosix(rootDir, v.imports);
+    const detail = `forbidden import: ${relFile} -> ${relImport}`;
+    return {
+      id: violationId(relFile, category ?? "", detail),
+      file: relFile,
+      category,
+      detail,
+      severity: "error"
+    };
+  });
+}
+var ForbiddenImportCollector = class {
+  category = "forbidden-imports";
+  getRules(_config, _rootDir) {
+    const description = "No forbidden imports allowed";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", description),
+        category: this.category,
+        description,
+        scope: "project"
+      }
+    ];
+  }
+  async collect(_config, rootDir) {
+    const registry = getDefaultRegistry();
+    const parser = registry.getByLanguage("typescript") ?? registry.getByLanguage("javascript");
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const violations = mapForbiddenImportViolations(
+      result.value.violations.filter((v) => v.reason === "FORBIDDEN_IMPORT"),
+      rootDir,
+      this.category
+    );
+    return [{ category: this.category, scope: "project", value: violations.length, violations }];
+  }
+};
+
+// src/architecture/collectors/module-size.ts
+import { readFile, readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { DEFAULT_SKIP_DIRS } from "@harness-engineering/graph";
+function isSkippedEntry(name) {
+  return name.startsWith(".") || DEFAULT_SKIP_DIRS.has(name);
+}
+function isTsSourceFile(name) {
+  if (!name.endsWith(".ts") && !name.endsWith(".tsx")) return false;
+  if (name.endsWith(".test.ts") || name.endsWith(".test.tsx") || name.endsWith(".spec.ts"))
+    return false;
+  return true;
+}
+async function countLoc(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return content.split("\n").filter((line) => line.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+async function buildModuleStats(rootDir, dir, tsFiles) {
+  let totalLoc = 0;
+  for (const f of tsFiles) {
+    totalLoc += await countLoc(f);
+  }
+  return {
+    modulePath: relativePosix(rootDir, dir),
+    fileCount: tsFiles.length,
+    totalLoc,
+    files: tsFiles.map((f) => relativePosix(rootDir, f))
+  };
+}
+async function scanDir(rootDir, dir, modules) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const tsFiles = [];
+  const subdirs = [];
+  for (const entry of entries) {
+    if (isSkippedEntry(entry.name)) continue;
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      subdirs.push(fullPath);
+      continue;
+    }
+    if (entry.isFile() && isTsSourceFile(entry.name)) {
+      tsFiles.push(fullPath);
+    }
+  }
+  if (tsFiles.length > 0) {
+    modules.push(await buildModuleStats(rootDir, dir, tsFiles));
+  }
+  for (const sub of subdirs) {
+    await scanDir(rootDir, sub, modules);
+  }
+}
+async function discoverModules(rootDir) {
+  const modules = [];
+  await scanDir(rootDir, rootDir, modules);
+  return modules;
+}
+function extractThresholds(config) {
+  const thresholds = config.thresholds["module-size"];
+  let maxLoc = Infinity;
+  let maxFiles = Infinity;
+  if (typeof thresholds === "object" && thresholds !== null) {
+    const t = thresholds;
+    if (t.maxLoc !== void 0) maxLoc = t.maxLoc;
+    if (t.maxFiles !== void 0) maxFiles = t.maxFiles;
+  }
+  return { maxLoc, maxFiles };
+}
+var ModuleSizeCollector = class {
+  category = "module-size";
+  getRules(config, _rootDir) {
+    const { maxLoc, maxFiles } = extractThresholds(config);
+    const rules = [];
+    if (maxLoc < Infinity) {
+      const desc = `Module LOC must not exceed ${maxLoc}`;
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    if (maxFiles < Infinity) {
+      const desc = `Module file count must not exceed ${maxFiles}`;
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    if (rules.length === 0) {
+      const desc = "Module size must stay within thresholds";
+      rules.push({
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      });
+    }
+    return rules;
+  }
+  async collect(config, rootDir) {
+    const modules = await discoverModules(rootDir);
+    const { maxLoc, maxFiles } = extractThresholds(config);
+    return modules.map((mod) => {
+      const violations = [];
+      if (mod.totalLoc > maxLoc) {
+        violations.push({
+          id: violationId(mod.modulePath, this.category, "totalLoc-exceeded"),
+          file: mod.modulePath,
+          detail: `Module has ${mod.totalLoc} lines of code (threshold: ${maxLoc})`,
+          severity: "warning"
+        });
+      }
+      if (mod.fileCount > maxFiles) {
+        violations.push({
+          id: violationId(mod.modulePath, this.category, "fileCount-exceeded"),
+          file: mod.modulePath,
+          detail: `Module has ${mod.fileCount} files (threshold: ${maxFiles})`,
+          severity: "warning"
+        });
+      }
+      return {
+        category: this.category,
+        scope: mod.modulePath,
+        value: mod.totalLoc,
+        violations,
+        metadata: { fileCount: mod.fileCount, totalLoc: mod.totalLoc }
+      };
+    });
+  }
+};
+
+// src/architecture/collectors/dep-depth.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join3, dirname as dirname2, resolve } from "path";
+import { DEFAULT_SKIP_DIRS as DEFAULT_SKIP_DIRS2 } from "@harness-engineering/graph";
+function extractImportSources(content, filePath) {
+  const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
+  const dynamicRegex = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+  const sources = [];
+  const dir = dirname2(filePath);
+  for (const regex of [importRegex, dynamicRegex]) {
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      let resolved = resolve(dir, match[1]);
+      if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+        resolved += ".ts";
+      }
+      sources.push(resolved);
+    }
+  }
+  return sources;
+}
+function isSkippedEntry2(name) {
+  return name.startsWith(".") || DEFAULT_SKIP_DIRS2.has(name);
+}
+function isTsSourceFile2(name) {
+  if (!name.endsWith(".ts") && !name.endsWith(".tsx")) return false;
+  return !name.endsWith(".test.ts") && !name.endsWith(".test.tsx") && !name.endsWith(".spec.ts");
+}
+async function scanDir2(d, results) {
+  let entries;
+  try {
+    entries = await readdir2(d, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (isSkippedEntry2(entry.name)) continue;
+    const fullPath = join3(d, entry.name);
+    if (entry.isDirectory()) {
+      await scanDir2(fullPath, results);
+    } else if (entry.isFile() && isTsSourceFile2(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+}
+async function collectTsFiles(dir) {
+  const results = [];
+  await scanDir2(dir, results);
+  return results;
+}
+function computeLongestChain(file, graph, visited, memo) {
+  if (memo.has(file)) return memo.get(file);
+  if (visited.has(file)) return 0;
+  visited.add(file);
+  const deps = graph.get(file) || [];
+  let maxDepth = 0;
+  for (const dep of deps) {
+    const depth = 1 + computeLongestChain(dep, graph, visited, memo);
+    if (depth > maxDepth) maxDepth = depth;
+  }
+  visited.delete(file);
+  memo.set(file, maxDepth);
+  return maxDepth;
+}
+var DepDepthCollector = class {
+  category = "dependency-depth";
+  getRules(config, _rootDir) {
+    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : null;
+    const desc = threshold !== null ? `Dependency chain depth must not exceed ${threshold}` : "Dependency chain depth must stay within thresholds";
+    return [
+      {
+        id: constraintRuleId(this.category, "project", desc),
+        category: this.category,
+        description: desc,
+        scope: "project"
+      }
+    ];
+  }
+  async buildImportGraph(allFiles) {
+    const graph = /* @__PURE__ */ new Map();
+    const fileSet = new Set(allFiles);
+    for (const file of allFiles) {
+      try {
+        const content = await readFile2(file, "utf-8");
+        graph.set(
+          file,
+          extractImportSources(content, file).filter((imp) => fileSet.has(imp))
+        );
+      } catch {
+        graph.set(file, []);
+      }
+    }
+    return graph;
+  }
+  buildModuleMap(allFiles, rootDir) {
+    const moduleMap = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const relDir = relativePosix(rootDir, dirname2(file));
+      if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
+      moduleMap.get(relDir).push(file);
+    }
+    return moduleMap;
+  }
+  async collect(config, rootDir) {
+    const allFiles = await collectTsFiles(rootDir);
+    const graph = await this.buildImportGraph(allFiles);
+    const moduleMap = this.buildModuleMap(allFiles, rootDir);
+    const memo = /* @__PURE__ */ new Map();
+    const threshold = typeof config.thresholds["dependency-depth"] === "number" ? config.thresholds["dependency-depth"] : Infinity;
+    const results = [];
+    for (const [modulePath, files] of moduleMap) {
+      const longestChain = files.reduce((max, file) => {
+        return Math.max(max, computeLongestChain(file, graph, /* @__PURE__ */ new Set(), memo));
+      }, 0);
+      const violations = [];
+      if (longestChain > threshold) {
+        violations.push({
+          id: violationId(modulePath, this.category, "depth-exceeded"),
+          file: modulePath,
+          detail: `Import chain depth is ${longestChain} (threshold: ${threshold})`,
+          severity: "warning"
+        });
+      }
+      results.push({
+        category: this.category,
+        scope: modulePath,
+        value: longestChain,
+        violations,
+        metadata: { longestChain }
+      });
+    }
+    return results;
+  }
+};
+
+// src/architecture/collectors/index.ts
+var defaultCollectors = [
+  new CircularDepsCollector(),
+  new LayerViolationCollector(),
+  new ComplexityCollector(),
+  new CouplingCollector(),
+  new ForbiddenImportCollector(),
+  new ModuleSizeCollector(),
+  new DepDepthCollector()
+];
+async function runAll(config, rootDir, collectors = defaultCollectors) {
+  const results = await Promise.allSettled(collectors.map((c) => c.collect(config, rootDir)));
+  const allResults = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      allResults.push(...result.value);
+    } else {
+      allResults.push({
+        category: collectors[i].category,
+        scope: "project",
+        value: 0,
+        violations: [],
+        metadata: { error: String(result.reason) }
+      });
+    }
+  }
+  return allResults;
+}
+
+// src/architecture/matchers.ts
+function architecture(options) {
+  return {
+    kind: "arch-handle",
+    scope: "project",
+    rootDir: options?.rootDir ?? process.cwd(),
+    config: options?.config
+  };
+}
+function archModule(modulePath, options) {
+  return {
+    kind: "arch-handle",
+    scope: modulePath,
+    rootDir: options?.rootDir ?? process.cwd(),
+    config: options?.config
+  };
+}
+function resolveConfig(handle) {
+  return ArchConfigSchema.parse(handle.config ?? {});
+}
+async function collectCategory(handle, collector) {
+  if ("_mockResults" in handle && handle._mockResults) {
+    return handle._mockResults;
+  }
+  const config = resolveConfig(handle);
+  return collector.collect(config, handle.rootDir);
+}
+function formatViolationList(violations, limit = 10) {
+  const lines = violations.slice(0, limit).map((v) => `  - ${v.file}: ${v.detail}`);
+  if (violations.length > limit) {
+    lines.push(`  ... and ${violations.length - limit} more`);
+  }
+  return lines.join("\n");
+}
+async function toHaveNoCircularDeps(received) {
+  const results = await collectCategory(received, new CircularDepsCollector());
+  const violations = results.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? "Expected circular dependencies but found none" : `Found ${violations.length} circular dependenc${violations.length === 1 ? "y" : "ies"}:
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveNoLayerViolations(received) {
+  const results = await collectCategory(received, new LayerViolationCollector());
+  const violations = results.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? "Expected layer violations but found none" : `Found ${violations.length} layer violation${violations.length === 1 ? "" : "s"}:
+${formatViolationList(violations)}`
+  };
+}
+async function toMatchBaseline(received, options) {
+  let diffResult;
+  if ("_mockDiff" in received && received._mockDiff) {
+    diffResult = received._mockDiff;
+  } else {
+    const config = resolveConfig(received);
+    const results = await runAll(config, received.rootDir);
+    const manager = new ArchBaselineManager(received.rootDir, config.baselinePath);
+    const baseline = manager.load();
+    if (!baseline) {
+      return {
+        pass: false,
+        message: () => "No baseline found. Run `harness check-arch --update-baseline` to create one."
+      };
+    }
+    diffResult = diff(results, baseline);
+  }
+  const tolerance = options?.tolerance ?? 0;
+  const effectiveNewCount = Math.max(0, diffResult.newViolations.length - tolerance);
+  const pass = effectiveNewCount === 0 && diffResult.regressions.length === 0;
+  return {
+    pass,
+    message: () => {
+      if (pass) {
+        return "Expected baseline regression but architecture matches baseline";
+      }
+      const parts = [];
+      if (diffResult.newViolations.length > 0) {
+        parts.push(
+          `${diffResult.newViolations.length} new violation${diffResult.newViolations.length === 1 ? "" : "s"}${tolerance > 0 ? ` (tolerance: ${tolerance})` : ""}:
+${formatViolationList(diffResult.newViolations)}`
+        );
+      }
+      if (diffResult.regressions.length > 0) {
+        const regLines = diffResult.regressions.map(
+          (r) => `  - ${r.category}: ${r.baselineValue} -> ${r.currentValue} (+${r.delta})`
+        );
+        parts.push(`Regressions:
+${regLines.join("\n")}`);
+      }
+      return `Baseline check failed:
+${parts.join("\n\n")}`;
+    }
+  };
+}
+function filterByScope(results, scope) {
+  return results.filter(
+    (r) => r.scope === scope || r.scope.startsWith(scope + "/") || r.scope === "project"
+  );
+}
+async function toHaveMaxComplexity(received, maxComplexity) {
+  const results = await collectCategory(received, new ComplexityCollector());
+  const scoped = filterByScope(results, received.scope);
+  const violations = scoped.flatMap((r) => r.violations);
+  const totalValue = scoped.reduce((sum, r) => sum + r.value, 0);
+  const pass = totalValue <= maxComplexity && violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected complexity to exceed ${maxComplexity} but it was within limits` : `Module '${received.scope}' has complexity violations (${violations.length} violation${violations.length === 1 ? "" : "s"}):
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveMaxCoupling(received, limits) {
+  const config = resolveConfig(received);
+  if (limits.fanIn !== void 0 || limits.fanOut !== void 0) {
+    config.thresholds.coupling = {
+      ...typeof config.thresholds.coupling === "object" ? config.thresholds.coupling : {},
+      ...limits.fanIn !== void 0 ? { maxFanIn: limits.fanIn } : {},
+      ...limits.fanOut !== void 0 ? { maxFanOut: limits.fanOut } : {}
+    };
+  }
+  const collector = new CouplingCollector();
+  const results = "_mockResults" in received && received._mockResults ? received._mockResults : await collector.collect(config, received.rootDir);
+  const scoped = filterByScope(results, received.scope);
+  const violations = scoped.flatMap((r) => r.violations);
+  const pass = violations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected coupling violations in '${received.scope}' but found none` : `Module '${received.scope}' has ${violations.length} coupling violation${violations.length === 1 ? "" : "s"} (fanIn limit: ${limits.fanIn ?? "none"}, fanOut limit: ${limits.fanOut ?? "none"}):
+${formatViolationList(violations)}`
+  };
+}
+async function toHaveMaxFileCount(received, maxFiles) {
+  const results = await collectCategory(received, new ModuleSizeCollector());
+  const scoped = filterByScope(results, received.scope);
+  const fileCount = scoped.reduce((max, r) => {
+    const meta = r.metadata;
+    const fc = typeof meta?.fileCount === "number" ? meta.fileCount : 0;
+    return fc > max ? fc : max;
+  }, 0);
+  const pass = fileCount <= maxFiles;
+  return {
+    pass,
+    message: () => pass ? `Expected file count in '${received.scope}' to exceed ${maxFiles} but it was ${fileCount}` : `Module '${received.scope}' has ${fileCount} files (limit: ${maxFiles})`
+  };
+}
+async function toNotDependOn(received, forbiddenModule) {
+  const results = await collectCategory(received, new ForbiddenImportCollector());
+  const allViolations = results.flatMap((r) => r.violations);
+  const scopePrefix = received.scope.replace(/\/+$/, "");
+  const forbiddenPrefix = forbiddenModule.replace(/\/+$/, "");
+  const relevantViolations = allViolations.filter(
+    (v) => (v.file === scopePrefix || v.file.startsWith(scopePrefix + "/")) && (v.detail.includes(forbiddenPrefix + "/") || v.detail.endsWith(forbiddenPrefix))
+  );
+  const pass = relevantViolations.length === 0;
+  return {
+    pass,
+    message: () => pass ? `Expected '${received.scope}' to depend on '${forbiddenModule}' but no such imports found` : `Module '${received.scope}' depends on '${forbiddenModule}' (${relevantViolations.length} import${relevantViolations.length === 1 ? "" : "s"}):
+${formatViolationList(relevantViolations)}`
+  };
+}
+async function toHaveMaxDepDepth(received, maxDepth) {
+  const results = await collectCategory(received, new DepDepthCollector());
+  const scoped = filterByScope(results, received.scope);
+  const maxActual = scoped.reduce((max, r) => r.value > max ? r.value : max, 0);
+  const pass = maxActual <= maxDepth;
+  return {
+    pass,
+    message: () => pass ? `Expected dependency depth in '${received.scope}' to exceed ${maxDepth} but it was ${maxActual}` : `Module '${received.scope}' has dependency depth ${maxActual} (limit: ${maxDepth})`
+  };
+}
+var archMatchers = {
+  toHaveNoCircularDeps,
+  toHaveNoLayerViolations,
+  toMatchBaseline,
+  toHaveMaxComplexity,
+  toHaveMaxCoupling,
+  toHaveMaxFileCount,
+  toNotDependOn,
+  toHaveMaxDepDepth
+};
+
+export {
+  detectCircularDeps,
+  detectCircularDepsInFiles,
+  violationId,
+  constraintRuleId,
+  CircularDepsCollector,
+  LayerViolationCollector,
+  ComplexityCollector,
+  CouplingCollector,
+  ForbiddenImportCollector,
+  ModuleSizeCollector,
+  DepDepthCollector,
+  defaultCollectors,
+  runAll,
+  ArchBaselineManager,
+  diff,
+  architecture,
+  archModule,
+  archMatchers
+};