@harness-engineering/core 0.10.0 → 0.11.0

package/dist/architecture/matchers.js

@@ -0,0 +1,1784 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/architecture/matchers.ts
+var matchers_exports = {};
+__export(matchers_exports, {
+  archMatchers: () => archMatchers,
+  archModule: () => archModule,
+  architecture: () => architecture
+});
+module.exports = __toCommonJS(matchers_exports);
+
+// src/architecture/types.ts
+var import_zod = require("zod");
+var ArchMetricCategorySchema = import_zod.z.enum([
+  "circular-deps",
+  "layer-violations",
+  "complexity",
+  "coupling",
+  "forbidden-imports",
+  "module-size",
+  "dependency-depth"
+]);
+var ViolationSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  // stable hash: sha256(relativePath + ':' + category + ':' + normalizedDetail)
+  file: import_zod.z.string(),
+  // relative to project root
+  category: ArchMetricCategorySchema.optional(),
+  // context for baseline reporting
+  detail: import_zod.z.string(),
+  // human-readable description
+  severity: import_zod.z.enum(["error", "warning"])
+});
+var MetricResultSchema = import_zod.z.object({
+  category: ArchMetricCategorySchema,
+  scope: import_zod.z.string(),
+  // e.g., 'project', 'src/services', 'src/api/routes.ts'
+  value: import_zod.z.number(),
+  // numeric metric (violation count, complexity score, etc.)
+  violations: import_zod.z.array(ViolationSchema),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+});
+var CategoryBaselineSchema = import_zod.z.object({
+  value: import_zod.z.number(),
+  // aggregate metric value at baseline time
+  violationIds: import_zod.z.array(import_zod.z.string())
+  // stable IDs of known violations (the allowlist)
+});
+var ArchBaselineSchema = import_zod.z.object({
+  version: import_zod.z.literal(1),
+  updatedAt: import_zod.z.string().datetime(),
+  // ISO 8601
+  updatedFrom: import_zod.z.string(),
+  // commit hash
+  metrics: import_zod.z.record(ArchMetricCategorySchema, CategoryBaselineSchema)
+});
+var CategoryRegressionSchema = import_zod.z.object({
+  category: ArchMetricCategorySchema,
+  baselineValue: import_zod.z.number(),
+  currentValue: import_zod.z.number(),
+  delta: import_zod.z.number()
+});
+var ArchDiffResultSchema = import_zod.z.object({
+  passed: import_zod.z.boolean(),
+  newViolations: import_zod.z.array(ViolationSchema),
+  // in current but not in baseline -> FAIL
+  resolvedViolations: import_zod.z.array(import_zod.z.string()),
+  // in baseline but not in current -> celebrate
+  preExisting: import_zod.z.array(import_zod.z.string()),
+  // in both -> allowed, tracked
+  regressions: import_zod.z.array(CategoryRegressionSchema)
+  // aggregate value exceeded baseline
+});
+var ThresholdConfigSchema = import_zod.z.record(
+  ArchMetricCategorySchema,
+  import_zod.z.union([import_zod.z.number(), import_zod.z.record(import_zod.z.string(), import_zod.z.number())])
+);
+var ArchConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(true),
+  baselinePath: import_zod.z.string().default(".harness/arch/baselines.json"),
+  thresholds: ThresholdConfigSchema.default({}),
+  modules: import_zod.z.record(import_zod.z.string(), ThresholdConfigSchema).default({})
+});
+var ConstraintRuleSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  // stable hash: sha256(category + ':' + scope + ':' + description)
+  category: ArchMetricCategorySchema,
+  description: import_zod.z.string(),
+  // e.g., "Layer 'services' must not import from 'ui'"
+  scope: import_zod.z.string(),
+  // e.g., 'src/services/', 'project'
+  targets: import_zod.z.array(import_zod.z.string()).optional()
+  // forward-compat for governs edges
+});
+
+// src/architecture/collectors/circular-deps.ts
+var import_node_path = require("path");
+
+// src/architecture/collectors/hash.ts
+var import_node_crypto = require("crypto");
+function violationId(relativePath, category, normalizedDetail) {
+  const path = relativePath.replace(/\\/g, "/");
+  const input = `${path}:${category}:${normalizedDetail}`;
+  return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+}
+function constraintRuleId(category, scope, description) {
+  const input = `${category}:${scope}:${description}`;
+  return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
+}
+
+// src/shared/result.ts
+var import_types = require("@harness-engineering/types");
+
+// src/shared/errors.ts
+function createError(code, message, details = {}, suggestions = []) {
+  return { code, message, details, suggestions };
+}
+
+// src/constraints/layers.ts
+var import_minimatch = require("minimatch");
+function resolveFileToLayer(file, layers) {
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      if ((0, import_minimatch.minimatch)(file, pattern)) {
+        return layer;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/shared/fs-utils.ts
+var import_fs = require("fs");
+var import_util = require("util");
+var import_glob = require("glob");
+var accessAsync = (0, import_util.promisify)(import_fs.access);
+var readFileAsync = (0, import_util.promisify)(import_fs.readFile);
+async function findFiles(pattern, cwd = process.cwd()) {
+  return (0, import_glob.glob)(pattern, { cwd, absolute: true });
+}
+
+// src/constraints/dependencies.ts
+var import_path = require("path");
+function resolveImportPath(importSource, fromFile, _rootDir) {
+  if (!importSource.startsWith(".") && !importSource.startsWith("/")) {
+    return null;
+  }
+  const fromDir = (0, import_path.dirname)(fromFile);
+  let resolved = (0, import_path.resolve)(fromDir, importSource);
+  if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+    resolved = resolved + ".ts";
+  }
+  return resolved.replace(/\\/g, "/");
+}
+function getImportType(imp) {
+  if (imp.kind === "type") return "type-only";
+  return "static";
+}
+async function buildDependencyGraph(files, parser, graphDependencyData) {
+  if (graphDependencyData) {
+    return (0, import_types.Ok)({
+      nodes: graphDependencyData.nodes,
+      edges: graphDependencyData.edges
+    });
+  }
+  const nodes = files.map((f) => f.replace(/\\/g, "/"));
+  const edges = [];
+  for (const file of files) {
+    const normalizedFile = file.replace(/\\/g, "/");
+    const parseResult = await parser.parseFile(file);
+    if (!parseResult.ok) {
+      continue;
+    }
+    const importsResult = parser.extractImports(parseResult.value);
+    if (!importsResult.ok) {
+      continue;
+    }
+    for (const imp of importsResult.value) {
+      const resolvedPath = resolveImportPath(imp.source, file, "");
+      if (resolvedPath) {
+        edges.push({
+          from: normalizedFile,
+          to: resolvedPath,
+          importType: getImportType(imp),
+          line: imp.location.line
+        });
+      }
+    }
+  }
+  return (0, import_types.Ok)({ nodes, edges });
+}
+function checkLayerViolations(graph, layers, rootDir) {
+  const violations = [];
+  for (const edge of graph.edges) {
+    const fromRelative = (0, import_path.relative)(rootDir, edge.from);
+    const toRelative = (0, import_path.relative)(rootDir, edge.to);
+    const fromLayer = resolveFileToLayer(fromRelative, layers);
+    const toLayer = resolveFileToLayer(toRelative, layers);
+    if (!fromLayer || !toLayer) continue;
+    if (fromLayer.name === toLayer.name) continue;
+    if (!fromLayer.allowedDependencies.includes(toLayer.name)) {
+      violations.push({
+        file: edge.from,
+        imports: edge.to,
+        fromLayer: fromLayer.name,
+        toLayer: toLayer.name,
+        reason: "WRONG_LAYER",
+        line: edge.line,
+        suggestion: `Move the dependency to an allowed layer (${fromLayer.allowedDependencies.join(", ") || "none"}) or update layer rules`
+      });
+    }
+  }
+  return violations;
+}
+async function validateDependencies(config) {
+  const { layers, rootDir, parser, fallbackBehavior = "error", graphDependencyData } = config;
+  if (graphDependencyData) {
+    const graphResult2 = await buildDependencyGraph([], parser, graphDependencyData);
+    if (!graphResult2.ok) {
+      return (0, import_types.Err)(graphResult2.error);
+    }
+    const violations2 = checkLayerViolations(graphResult2.value, layers, rootDir);
+    return (0, import_types.Ok)({
+      valid: violations2.length === 0,
+      violations: violations2,
+      graph: graphResult2.value
+    });
+  }
+  const healthResult = await parser.health();
+  if (!healthResult.ok || !healthResult.value.available) {
+    if (fallbackBehavior === "skip") {
+      return (0, import_types.Ok)({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    if (fallbackBehavior === "warn") {
+      console.warn(`Parser ${parser.name} unavailable, skipping validation`);
+      return (0, import_types.Ok)({
+        valid: true,
+        violations: [],
+        graph: { nodes: [], edges: [] },
+        skipped: true,
+        reason: "Parser unavailable"
+      });
+    }
+    return (0, import_types.Err)(
+      createError(
+        "PARSER_UNAVAILABLE",
+        `Parser ${parser.name} is not available`,
+        { parser: parser.name },
+        ["Install required runtime", "Use different parser", 'Set fallbackBehavior: "skip"']
+      )
+    );
+  }
+  const allFiles = [];
+  for (const layer of layers) {
+    for (const pattern of layer.patterns) {
+      const files = await findFiles(pattern, rootDir);
+      allFiles.push(...files);
+    }
+  }
+  const uniqueFiles = [...new Set(allFiles)];
+  const graphResult = await buildDependencyGraph(uniqueFiles, parser);
+  if (!graphResult.ok) {
+    return (0, import_types.Err)(graphResult.error);
+  }
+  const violations = checkLayerViolations(graphResult.value, layers, rootDir);
+  return (0, import_types.Ok)({
+    valid: violations.length === 0,
+    violations,
+    graph: graphResult.value
+  });
+}
+
+// src/constraints/circular-deps.ts
+function tarjanSCC(graph) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const stack = [];
+  const sccs = [];
+  let index = 0;
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    adjacency.set(node, []);
+  }
+  for (const edge of graph.edges) {
+    const neighbors = adjacency.get(edge.from);
+    if (neighbors && graph.nodes.includes(edge.to)) {
+      neighbors.push(edge.to);
+    }
+  }
+  function strongConnect(node) {
+    nodeMap.set(node, {
+      index,
+      lowlink: index,
+      onStack: true
+    });
+    index++;
+    stack.push(node);
+    const neighbors = adjacency.get(node) ?? [];
+    for (const neighbor of neighbors) {
+      const neighborData = nodeMap.get(neighbor);
+      if (!neighborData) {
+        strongConnect(neighbor);
+        const nodeData2 = nodeMap.get(node);
+        const updatedNeighborData = nodeMap.get(neighbor);
+        nodeData2.lowlink = Math.min(nodeData2.lowlink, updatedNeighborData.lowlink);
+      } else if (neighborData.onStack) {
+        const nodeData2 = nodeMap.get(node);
+        nodeData2.lowlink = Math.min(nodeData2.lowlink, neighborData.index);
+      }
+    }
+    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 (scc.length > 1) {
+        sccs.push(scc);
+      } else if (scc.length === 1) {
+        const selfNode = scc[0];
+        const selfNeighbors = adjacency.get(selfNode) ?? [];
+        if (selfNeighbors.includes(selfNode)) {
+          sccs.push(scc);
+        }
+      }
+    }
+  }
+  for (const node of graph.nodes) {
+    if (!nodeMap.has(node)) {
+      strongConnect(node);
+    }
+  }
+  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 (0, import_types.Ok)({
+    hasCycles: cycles.length > 0,
+    cycles,
+    largestCycle
+  });
+}
+
+// src/architecture/collectors/circular-deps.ts
+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 stubParser = {
+      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 } })
+    };
+    const graphResult = await buildDependencyGraph(files, stubParser);
+    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 = cycles.map((cycle) => {
+      const cyclePath = cycle.cycle.map((f) => (0, import_node_path.relative)(rootDir, f)).join(" -> ");
+      const firstFile = (0, import_node_path.relative)(rootDir, cycle.cycle[0]);
+      return {
+        id: violationId(firstFile, this.category, cyclePath),
+        file: firstFile,
+        detail: `Circular dependency: ${cyclePath}`,
+        severity: cycle.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: cycles.length,
+        violations,
+        metadata: { largestCycle, cycleCount: cycles.length }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/layer-violations.ts
+var import_node_path2 = require("path");
+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 stubParser = {
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "" } }),
+      extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      health: async () => ({ ok: true, value: { available: true } })
+    };
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser: stubParser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const layerViolations = result.value.violations.filter(
+      (v) => v.reason === "WRONG_LAYER"
+    );
+    const violations = layerViolations.map((v) => {
+      const relFile = (0, import_node_path2.relative)(rootDir, v.file);
+      const relImport = (0, import_node_path2.relative)(rootDir, v.imports);
+      const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
+      return {
+        id: violationId(relFile, this.category, detail),
+        file: relFile,
+        category: this.category,
+        detail,
+        severity: "error"
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations
+      }
+    ];
+  }
+};
+
+// src/architecture/baseline-manager.ts
+var import_node_fs = require("fs");
+var import_node_crypto2 = require("crypto");
+var import_node_path3 = require("path");
+var ArchBaselineManager = class {
+  baselinesPath;
+  constructor(projectRoot, baselinePath) {
+    this.baselinesPath = baselinePath ? (0, import_node_path3.join)(projectRoot, baselinePath) : (0, import_node_path3.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)
+        };
+      }
+    }
+    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 (!(0, import_node_fs.existsSync)(this.baselinesPath)) {
+      console.error(`Baseline file not found at: ${this.baselinesPath}`);
+      return null;
+    }
+    try {
+      const raw = (0, import_node_fs.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;
+    }
+  }
+  /**
+   * 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 = (0, import_node_path3.dirname)(this.baselinesPath);
+    if (!(0, import_node_fs.existsSync)(dir)) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    }
+    const tmp = this.baselinesPath + "." + (0, import_node_crypto2.randomBytes)(4).toString("hex") + ".tmp";
+    (0, import_node_fs.writeFileSync)(tmp, JSON.stringify(baseline, null, 2));
+    (0, import_node_fs.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 diff(current, baseline) {
+  const aggregated = aggregateByCategory(current);
+  const newViolations = [];
+  const resolvedViolations = [];
+  const preExisting = [];
+  const regressions = [];
+  const visitedCategories = /* @__PURE__ */ new Set();
+  for (const [category, agg] of aggregated) {
+    visitedCategories.add(category);
+    const baselineCategory = baseline.metrics[category];
+    const baselineViolationIds = new Set(baselineCategory?.violationIds ?? []);
+    const baselineValue = baselineCategory?.value ?? 0;
+    for (const violation of agg.violations) {
+      if (baselineViolationIds.has(violation.id)) {
+        preExisting.push(violation.id);
+      } else {
+        newViolations.push(violation);
+      }
+    }
+    const currentViolationIds = new Set(agg.violations.map((v) => v.id));
+    if (baselineCategory) {
+      for (const id of baselineCategory.violationIds) {
+        if (!currentViolationIds.has(id)) {
+          resolvedViolations.push(id);
+        }
+      }
+    }
+    if (baselineCategory && agg.value > baselineValue) {
+      regressions.push({
+        category,
+        baselineValue,
+        currentValue: agg.value,
+        delta: agg.value - baselineValue
+      });
+    }
+  }
+  for (const [category, baselineCategory] of Object.entries(baseline.metrics)) {
+    if (!visitedCategories.has(category) && baselineCategory) {
+      for (const id of baselineCategory.violationIds) {
+        resolvedViolations.push(id);
+      }
+    }
+  }
+  const passed = newViolations.length === 0 && regressions.length === 0;
+  return {
+    passed,
+    newViolations,
+    resolvedViolations,
+    preExisting,
+    regressions
+  };
+}
+
+// src/architecture/collectors/complexity.ts
+var import_node_path4 = require("path");
+
+// src/entropy/detectors/complexity.ts
+var import_promises = require("fs/promises");
+var DEFAULT_THRESHOLDS = {
+  cyclomaticComplexity: { error: 15, warn: 10 },
+  nestingDepth: { warn: 4 },
+  functionLength: { warn: 50 },
+  parameterCount: { warn: 5 },
+  fileLength: { info: 300 },
+  hotspotPercentile: { error: 95 }
+};
+function extractFunctions(content) {
+  const functions = [];
+  const lines = content.split("\n");
+  const patterns = [
+    // function declarations: function name(params) {
+    /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
+    // method declarations: name(params) {
+    /^\s*(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*[^{]+)?\s*\{/,
+    // arrow functions assigned to const/let/var: const name = (params) =>
+    /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*[^=]+)?\s*=>/,
+    // arrow functions assigned to const/let/var with single param: const name = param =>
+    /^\s*(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(\w+)\s*=>/
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of patterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] ?? "anonymous";
+        const paramsStr = match[2] || "";
+        const params = paramsStr.trim() === "" ? 0 : paramsStr.split(",").length;
+        const endLine = findFunctionEnd(lines, i);
+        const body = lines.slice(i, endLine + 1).join("\n");
+        functions.push({
+          name,
+          line: i + 1,
+          params,
+          startLine: i + 1,
+          endLine: endLine + 1,
+          body
+        });
+        break;
+      }
+    }
+  }
+  return functions;
+}
+function findFunctionEnd(lines, startIdx) {
+  let depth = 0;
+  let foundOpen = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        foundOpen = true;
+      } else if (ch === "}") {
+        depth--;
+        if (foundOpen && depth === 0) {
+          return i;
+        }
+      }
+    }
+  }
+  return lines.length - 1;
+}
+function computeCyclomaticComplexity(body) {
+  let complexity = 1;
+  const decisionPatterns = [
+    /\bif\s*\(/g,
+    /\belse\s+if\s*\(/g,
+    /\bwhile\s*\(/g,
+    /\bfor\s*\(/g,
+    /\bcase\s+/g,
+    /&&/g,
+    /\|\|/g,
+    /\?(?!=)/g,
+    // Ternary ? but not ?. or ??
+    /\bcatch\s*\(/g
+  ];
+  for (const pattern of decisionPatterns) {
+    const matches = body.match(pattern);
+    if (matches) {
+      complexity += matches.length;
+    }
+  }
+  const elseIfMatches = body.match(/\belse\s+if\s*\(/g);
+  if (elseIfMatches) {
+    complexity -= elseIfMatches.length;
+  }
+  return complexity;
+}
+function computeNestingDepth(body) {
+  let maxDepth = 0;
+  let currentDepth = 0;
+  let functionBodyStarted = false;
+  for (const ch of body) {
+    if (ch === "{") {
+      if (!functionBodyStarted) {
+        functionBodyStarted = true;
+        continue;
+      }
+      currentDepth++;
+      if (currentDepth > maxDepth) {
+        maxDepth = currentDepth;
+      }
+    } else if (ch === "}") {
+      if (currentDepth > 0) {
+        currentDepth--;
+      }
+    }
+  }
+  return maxDepth;
+}
+async function detectComplexityViolations(snapshot, config, graphData) {
+  const violations = [];
+  const thresholds = {
+    cyclomaticComplexity: {
+      error: config?.thresholds?.cyclomaticComplexity?.error ?? DEFAULT_THRESHOLDS.cyclomaticComplexity.error,
+      warn: config?.thresholds?.cyclomaticComplexity?.warn ?? DEFAULT_THRESHOLDS.cyclomaticComplexity.warn
+    },
+    nestingDepth: {
+      warn: config?.thresholds?.nestingDepth?.warn ?? DEFAULT_THRESHOLDS.nestingDepth.warn
+    },
+    functionLength: {
+      warn: config?.thresholds?.functionLength?.warn ?? DEFAULT_THRESHOLDS.functionLength.warn
+    },
+    parameterCount: {
+      warn: config?.thresholds?.parameterCount?.warn ?? DEFAULT_THRESHOLDS.parameterCount.warn
+    },
+    fileLength: {
+      info: config?.thresholds?.fileLength?.info ?? DEFAULT_THRESHOLDS.fileLength.info
+    }
+  };
+  let totalFunctions = 0;
+  for (const file of snapshot.files) {
+    let content;
+    try {
+      content = await (0, import_promises.readFile)(file.path, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    if (lines.length > thresholds.fileLength.info) {
+      violations.push({
+        file: file.path,
+        function: "<file>",
+        line: 1,
+        metric: "fileLength",
+        value: lines.length,
+        threshold: thresholds.fileLength.info,
+        tier: 3,
+        severity: "info",
+        message: `File has ${lines.length} lines (threshold: ${thresholds.fileLength.info})`
+      });
+    }
+    const functions = extractFunctions(content);
+    totalFunctions += functions.length;
+    for (const fn of functions) {
+      const complexity = computeCyclomaticComplexity(fn.body);
+      if (complexity > thresholds.cyclomaticComplexity.error) {
+        violations.push({
+          file: file.path,
+          function: fn.name,
+          line: fn.line,
+          metric: "cyclomaticComplexity",
+          value: complexity,
+          threshold: thresholds.cyclomaticComplexity.error,
+          tier: 1,
+          severity: "error",
+          message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (error threshold: ${thresholds.cyclomaticComplexity.error})`
+        });
+      } else if (complexity > thresholds.cyclomaticComplexity.warn) {
+        violations.push({
+          file: file.path,
+          function: fn.name,
+          line: fn.line,
+          metric: "cyclomaticComplexity",
+          value: complexity,
+          threshold: thresholds.cyclomaticComplexity.warn,
+          tier: 2,
+          severity: "warning",
+          message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (warning threshold: ${thresholds.cyclomaticComplexity.warn})`
+        });
+      }
+      const nestingDepth = computeNestingDepth(fn.body);
+      if (nestingDepth > thresholds.nestingDepth.warn) {
+        violations.push({
+          file: file.path,
+          function: fn.name,
+          line: fn.line,
+          metric: "nestingDepth",
+          value: nestingDepth,
+          threshold: thresholds.nestingDepth.warn,
+          tier: 2,
+          severity: "warning",
+          message: `Function "${fn.name}" has nesting depth of ${nestingDepth} (threshold: ${thresholds.nestingDepth.warn})`
+        });
+      }
+      const fnLength = fn.endLine - fn.startLine + 1;
+      if (fnLength > thresholds.functionLength.warn) {
+        violations.push({
+          file: file.path,
+          function: fn.name,
+          line: fn.line,
+          metric: "functionLength",
+          value: fnLength,
+          threshold: thresholds.functionLength.warn,
+          tier: 2,
+          severity: "warning",
+          message: `Function "${fn.name}" is ${fnLength} lines long (threshold: ${thresholds.functionLength.warn})`
+        });
+      }
+      if (fn.params > thresholds.parameterCount.warn) {
+        violations.push({
+          file: file.path,
+          function: fn.name,
+          line: fn.line,
+          metric: "parameterCount",
+          value: fn.params,
+          threshold: thresholds.parameterCount.warn,
+          tier: 2,
+          severity: "warning",
+          message: `Function "${fn.name}" has ${fn.params} parameters (threshold: ${thresholds.parameterCount.warn})`
+        });
+      }
+      if (graphData) {
+        const hotspot = graphData.hotspots.find(
+          (h) => h.file === file.path && h.function === fn.name
+        );
+        if (hotspot && hotspot.hotspotScore > graphData.percentile95Score) {
+          violations.push({
+            file: file.path,
+            function: fn.name,
+            line: fn.line,
+            metric: "hotspotScore",
+            value: hotspot.hotspotScore,
+            threshold: graphData.percentile95Score,
+            tier: 1,
+            severity: "error",
+            message: `Function "${fn.name}" is a complexity hotspot (score: ${hotspot.hotspotScore}, p95: ${graphData.percentile95Score})`
+          });
+        }
+      }
+    }
+  }
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return (0, import_types.Ok)({
+    violations,
+    stats: {
+      filesAnalyzed: snapshot.files.length,
+      functionsAnalyzed: totalFunctions,
+      violationCount: violations.length,
+      errorCount,
+      warningCount,
+      infoCount
+    }
+  });
+}
+
+// src/architecture/collectors/complexity.ts
+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 = {
+      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
+    };
+    const complexityThreshold = _config.thresholds.complexity;
+    const maxComplexity = typeof complexityThreshold === "number" ? complexityThreshold : complexityThreshold?.max ?? 15;
+    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 filtered = complexityViolations.filter(
+      (v) => v.severity === "error" || v.severity === "warning"
+    );
+    const violations = filtered.map((v) => {
+      const relFile = (0, import_node_path4.relative)(rootDir, v.file);
+      const idDetail = `${v.metric}:${v.function}`;
+      return {
+        id: violationId(relFile, this.category, idDetail),
+        file: relFile,
+        category: this.category,
+        detail: `${v.metric}=${v.value} in ${v.function} (threshold: ${v.threshold})`,
+        severity: v.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: {
+          filesAnalyzed: stats.filesAnalyzed,
+          functionsAnalyzed: stats.functionsAnalyzed
+        }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/coupling.ts
+var import_node_path5 = require("path");
+
+// src/entropy/detectors/coupling.ts
+var DEFAULT_THRESHOLDS2 = {
+  fanOut: { warn: 15 },
+  fanIn: { info: 20 },
+  couplingRatio: { warn: 0.7 },
+  transitiveDependencyDepth: { info: 30 }
+};
+function computeMetricsFromSnapshot(snapshot) {
+  const fanInMap = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const resolved = resolveImportSource(imp.source, file.path, snapshot);
+      if (resolved) {
+        fanInMap.set(resolved, (fanInMap.get(resolved) || 0) + 1);
+      }
+    }
+  }
+  return snapshot.files.map((file) => {
+    const fanOut = file.imports.length;
+    const fanIn = fanInMap.get(file.path) || 0;
+    const total = fanIn + fanOut;
+    const couplingRatio = total > 0 ? fanOut / total : 0;
+    return {
+      file: file.path,
+      fanIn,
+      fanOut,
+      couplingRatio,
+      transitiveDepth: 0
+    };
+  });
+}
+function resolveRelativePath(from, source) {
+  const dir = from.includes("/") ? from.substring(0, from.lastIndexOf("/")) : ".";
+  const parts = dir.split("/");
+  for (const segment of source.split("/")) {
+    if (segment === ".") continue;
+    if (segment === "..") {
+      parts.pop();
+    } else {
+      parts.push(segment);
+    }
+  }
+  return parts.join("/");
+}
+function resolveImportSource(source, fromFile, snapshot) {
+  if (!source.startsWith(".") && !source.startsWith("/")) {
+    return void 0;
+  }
+  const resolved = resolveRelativePath(fromFile, source);
+  const filePaths = snapshot.files.map((f) => f.path);
+  const candidates = [
+    resolved,
+    `${resolved}.ts`,
+    `${resolved}.tsx`,
+    `${resolved}/index.ts`,
+    `${resolved}/index.tsx`
+  ];
+  for (const candidate of candidates) {
+    const match = filePaths.find((fp) => fp === candidate);
+    if (match) return match;
+  }
+  return void 0;
+}
+function checkViolations(metrics, config) {
+  const thresholds = {
+    fanOut: { ...DEFAULT_THRESHOLDS2.fanOut, ...config?.thresholds?.fanOut },
+    fanIn: { ...DEFAULT_THRESHOLDS2.fanIn, ...config?.thresholds?.fanIn },
+    couplingRatio: { ...DEFAULT_THRESHOLDS2.couplingRatio, ...config?.thresholds?.couplingRatio },
+    transitiveDependencyDepth: {
+      ...DEFAULT_THRESHOLDS2.transitiveDependencyDepth,
+      ...config?.thresholds?.transitiveDependencyDepth
+    }
+  };
+  const violations = [];
+  for (const m of metrics) {
+    if (thresholds.fanOut.warn !== void 0 && m.fanOut > thresholds.fanOut.warn) {
+      violations.push({
+        file: m.file,
+        metric: "fanOut",
+        value: m.fanOut,
+        threshold: thresholds.fanOut.warn,
+        tier: 2,
+        severity: "warning",
+        message: `File has ${m.fanOut} imports (threshold: ${thresholds.fanOut.warn})`
+      });
+    }
+    if (thresholds.fanIn.info !== void 0 && m.fanIn > thresholds.fanIn.info) {
+      violations.push({
+        file: m.file,
+        metric: "fanIn",
+        value: m.fanIn,
+        threshold: thresholds.fanIn.info,
+        tier: 3,
+        severity: "info",
+        message: `File is imported by ${m.fanIn} files (threshold: ${thresholds.fanIn.info})`
+      });
+    }
+    const totalConnections = m.fanIn + m.fanOut;
+    if (totalConnections > 5 && thresholds.couplingRatio.warn !== void 0 && m.couplingRatio > thresholds.couplingRatio.warn) {
+      violations.push({
+        file: m.file,
+        metric: "couplingRatio",
+        value: m.couplingRatio,
+        threshold: thresholds.couplingRatio.warn,
+        tier: 2,
+        severity: "warning",
+        message: `Coupling ratio is ${m.couplingRatio.toFixed(2)} (threshold: ${thresholds.couplingRatio.warn})`
+      });
+    }
+    if (thresholds.transitiveDependencyDepth.info !== void 0 && m.transitiveDepth > thresholds.transitiveDependencyDepth.info) {
+      violations.push({
+        file: m.file,
+        metric: "transitiveDependencyDepth",
+        value: m.transitiveDepth,
+        threshold: thresholds.transitiveDependencyDepth.info,
+        tier: 3,
+        severity: "info",
+        message: `Transitive dependency depth is ${m.transitiveDepth} (threshold: ${thresholds.transitiveDependencyDepth.info})`
+      });
+    }
+  }
+  return violations;
+}
+async function detectCouplingViolations(snapshot, config, graphData) {
+  let metrics;
+  if (graphData) {
+    metrics = graphData.files.map((f) => ({
+      file: f.file,
+      fanIn: f.fanIn,
+      fanOut: f.fanOut,
+      couplingRatio: f.couplingRatio,
+      transitiveDepth: f.transitiveDepth
+    }));
+  } else {
+    metrics = computeMetricsFromSnapshot(snapshot);
+  }
+  const violations = checkViolations(metrics, config);
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return (0, import_types.Ok)({
+    violations,
+    stats: {
+      filesAnalyzed: metrics.length,
+      violationCount: violations.length,
+      warningCount,
+      infoCount
+    }
+  });
+}
+
+// src/architecture/collectors/coupling.ts
+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 = {
+      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
+    };
+    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 filtered = couplingViolations.filter(
+      (v) => v.severity === "error" || v.severity === "warning"
+    );
+    const violations = filtered.map((v) => {
+      const relFile = (0, import_node_path5.relative)(rootDir, v.file);
+      const idDetail = `${v.metric}`;
+      return {
+        id: violationId(relFile, this.category, idDetail),
+        file: relFile,
+        category: this.category,
+        detail: `${v.metric}=${v.value} (threshold: ${v.threshold})`,
+        severity: v.severity
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations,
+        metadata: { filesAnalyzed: stats.filesAnalyzed }
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/forbidden-imports.ts
+var import_node_path6 = require("path");
+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 stubParser = {
+      name: "typescript",
+      extensions: [".ts", ".tsx"],
+      parseFile: async () => ({ ok: false, error: { code: "PARSE_ERROR", message: "" } }),
+      extractImports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      extractExports: () => ({ ok: false, error: { code: "EXTRACT_ERROR", message: "" } }),
+      health: async () => ({ ok: true, value: { available: true } })
+    };
+    const result = await validateDependencies({
+      layers: [],
+      rootDir,
+      parser: stubParser,
+      fallbackBehavior: "skip"
+    });
+    if (!result.ok) {
+      return [
+        {
+          category: this.category,
+          scope: "project",
+          value: 0,
+          violations: [],
+          metadata: { error: "Failed to validate dependencies" }
+        }
+      ];
+    }
+    const forbidden = result.value.violations.filter(
+      (v) => v.reason === "FORBIDDEN_IMPORT"
+    );
+    const violations = forbidden.map((v) => {
+      const relFile = (0, import_node_path6.relative)(rootDir, v.file);
+      const relImport = (0, import_node_path6.relative)(rootDir, v.imports);
+      const detail = `forbidden import: ${relFile} -> ${relImport}`;
+      return {
+        id: violationId(relFile, this.category, detail),
+        file: relFile,
+        category: this.category,
+        detail,
+        severity: "error"
+      };
+    });
+    return [
+      {
+        category: this.category,
+        scope: "project",
+        value: violations.length,
+        violations
+      }
+    ];
+  }
+};
+
+// src/architecture/collectors/module-size.ts
+var import_promises2 = require("fs/promises");
+var import_node_path7 = require("path");
+async function discoverModules(rootDir) {
+  const modules = [];
+  async function scanDir(dir) {
+    let entries;
+    try {
+      entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const tsFiles = [];
+    const subdirs = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
+        continue;
+      }
+      const fullPath = (0, import_node_path7.join)(dir, entry.name);
+      if (entry.isDirectory()) {
+        subdirs.push(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
+        tsFiles.push(fullPath);
+      }
+    }
+    if (tsFiles.length > 0) {
+      let totalLoc = 0;
+      for (const f of tsFiles) {
+        try {
+          const content = await (0, import_promises2.readFile)(f, "utf-8");
+          totalLoc += content.split("\n").filter((line) => line.trim().length > 0).length;
+        } catch {
+        }
+      }
+      modules.push({
+        modulePath: (0, import_node_path7.relative)(rootDir, dir),
+        fileCount: tsFiles.length,
+        totalLoc,
+        files: tsFiles.map((f) => (0, import_node_path7.relative)(rootDir, f))
+      });
+    }
+    for (const sub of subdirs) {
+      await scanDir(sub);
+    }
+  }
+  await scanDir(rootDir);
+  return modules;
+}
+var ModuleSizeCollector = class {
+  category = "module-size";
+  getRules(config, _rootDir) {
+    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;
+    }
+    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 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 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
+var import_promises3 = require("fs/promises");
+var import_node_path8 = require("path");
+function extractImportSources(content, filePath) {
+  const importRegex = /(?:import|export)\s+.*?from\s+['"](\.[^'"]+)['"]/g;
+  const dynamicRegex = /import\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+  const sources = [];
+  const dir = (0, import_node_path8.dirname)(filePath);
+  for (const regex of [importRegex, dynamicRegex]) {
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      let resolved = (0, import_node_path8.resolve)(dir, match[1]);
+      if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
+        resolved += ".ts";
+      }
+      sources.push(resolved);
+    }
+  }
+  return sources;
+}
+async function collectTsFiles(dir) {
+  const results = [];
+  async function scan(d) {
+    let entries;
+    try {
+      entries = await (0, import_promises3.readdir)(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
+        continue;
+      const fullPath = (0, import_node_path8.join)(d, entry.name);
+      if (entry.isDirectory()) {
+        await scan(fullPath);
+      } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) && !entry.name.endsWith(".test.ts") && !entry.name.endsWith(".test.tsx") && !entry.name.endsWith(".spec.ts")) {
+        results.push(fullPath);
+      }
+    }
+  }
+  await scan(dir);
+  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 collect(config, rootDir) {
+    const allFiles = await collectTsFiles(rootDir);
+    const graph = /* @__PURE__ */ new Map();
+    const fileSet = new Set(allFiles);
+    for (const file of allFiles) {
+      try {
+        const content = await (0, import_promises3.readFile)(file, "utf-8");
+        const imports = extractImportSources(content, file).filter((imp) => fileSet.has(imp));
+        graph.set(file, imports);
+      } catch {
+        graph.set(file, []);
+      }
+    }
+    const moduleMap = /* @__PURE__ */ new Map();
+    for (const file of allFiles) {
+      const relDir = (0, import_node_path8.relative)(rootDir, (0, import_node_path8.dirname)(file));
+      if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
+      moduleMap.get(relDir).push(file);
+    }
+    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) {
+      let longestChain = 0;
+      for (const file of files) {
+        const depth = computeLongestChain(file, graph, /* @__PURE__ */ new Set(), memo);
+        if (depth > longestChain) longestChain = depth;
+      }
+      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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  archMatchers,
+  archModule,
+  architecture
+});