@harness-engineering/core 0.13.0 → 0.14.0

package/dist/architecture/matchers.js

@@ -110,14 +110,10 @@ var ConstraintRuleSchema = import_zod.z.object({
   // 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}`;
+  const input = `${relativePath}:${category}:${normalizedDetail}`;
   return (0, import_node_crypto.createHash)("sha256").update(input).digest("hex");
 }
 function constraintRuleId(category, scope, description) {
@@ -149,12 +145,16 @@ function resolveFileToLayer(file, layers) {
 // src/shared/fs-utils.ts
 var import_fs = require("fs");
 var import_util = require("util");
+var import_node_path = require("path");
 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 });
 }
+function relativePosix(from, to) {
+  return (0, import_node_path.relative)(from, to).replaceAll("\\", "/");
+}
 
 // src/constraints/dependencies.ts
 var import_path = require("path");
@@ -209,8 +209,8 @@ async function buildDependencyGraph(files, parser, graphDependencyData) {
 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 fromRelative = relativePosix(rootDir, edge.from);
+    const toRelative = relativePosix(rootDir, edge.to);
     const fromLayer = resolveFileToLayer(fromRelative, layers);
     const toLayer = resolveFileToLayer(toRelative, layers);
     if (!fromLayer || !toLayer) continue;
@@ -294,65 +294,71 @@ async function validateDependencies(config) {
 }
 
 // src/constraints/circular-deps.ts
-function tarjanSCC(graph) {
-  const nodeMap = /* @__PURE__ */ new Map();
-  const stack = [];
-  const sccs = [];
-  let index = 0;
+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 && graph.nodes.includes(edge.to)) {
+    if (neighbors && nodeSet.has(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);
-      }
+  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);
     }
-    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);
-        }
-      }
+  }
+}
+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)) {
-      strongConnect(node);
+      strongConnectImpl(node, nodeMap, stack, adjacency, sccs, indexRef);
     }
   }
   return sccs;
@@ -433,8 +439,8 @@ var CircularDepsCollector = class {
     }
     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]);
+      const cyclePath = cycle.cycle.map((f) => relativePosix(rootDir, f)).join(" -> ");
+      const firstFile = relativePosix(rootDir, cycle.cycle[0]);
       return {
         id: violationId(firstFile, this.category, cyclePath),
         file: firstFile,
@@ -455,7 +461,6 @@ var CircularDepsCollector = class {
 };
 
 // src/architecture/collectors/layer-violations.ts
-var import_node_path2 = require("path");
 var LayerViolationCollector = class {
   category = "layer-violations";
   getRules(_config, _rootDir) {
@@ -499,8 +504,8 @@ var LayerViolationCollector = class {
       (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 relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `${v.fromLayer} -> ${v.toLayer}: ${relFile} imports ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -524,11 +529,11 @@ var LayerViolationCollector = class {
 // src/architecture/baseline-manager.ts
 var import_node_fs = require("fs");
 var import_node_crypto2 = require("crypto");
-var import_node_path3 = require("path");
+var import_node_path2 = 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");
+    this.baselinesPath = baselinePath ? (0, import_node_path2.join)(projectRoot, baselinePath) : (0, import_node_path2.join)(projectRoot, ".harness", "arch", "baselines.json");
   }
   /**
    * Snapshot the current metric results into an ArchBaseline.
@@ -589,7 +594,7 @@ var ArchBaselineManager = class {
    * Uses atomic write (write to temp file, then rename) to prevent corruption.
    */
   save(baseline) {
-    const dir = (0, import_node_path3.dirname)(this.baselinesPath);
+    const dir = (0, import_node_path2.dirname)(this.baselinesPath);
     if (!(0, import_node_fs.existsSync)(dir)) {
       (0, import_node_fs.mkdirSync)(dir, { recursive: true });
     }
@@ -616,6 +621,31 @@ function aggregateByCategory(results) {
   }
   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 diff(current, baseline) {
   const aggregated = aggregateByCategory(current);
   const newViolations = [];
@@ -628,21 +658,11 @@ function diff(current, baseline) {
     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 classified = classifyViolations(agg.violations, baselineViolationIds);
+    newViolations.push(...classified.newViolations);
+    preExisting.push(...classified.preExisting);
     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);
-        }
-      }
-    }
+    resolvedViolations.push(...findResolvedViolations(baselineCategory, currentViolationIds));
     if (baselineCategory && agg.value > baselineValue) {
       regressions.push({
         category,
@@ -652,16 +672,9 @@ function diff(current, baseline) {
       });
     }
   }
-  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;
+  resolvedViolations.push(...collectOrphanedBaselineViolations(baseline, visitedCategories));
   return {
-    passed,
+    passed: newViolations.length === 0 && regressions.length === 0,
     newViolations,
     resolvedViolations,
     preExisting,
@@ -669,9 +682,6 @@ function diff(current, baseline) {
   };
 }
 
-// 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 = {
@@ -682,22 +692,22 @@ var DEFAULT_THRESHOLDS = {
   fileLength: { info: 300 },
   hotspotPercentile: { error: 95 }
 };
+var FUNCTION_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*=>/
+];
 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) {
+    for (const pattern of FUNCTION_PATTERNS) {
       const match = line.match(pattern);
       if (match) {
         const name = match[1] ?? "anonymous";
@@ -786,26 +796,155 @@ function computeNestingDepth(body) {
   }
   return maxDepth;
 }
-async function detectComplexityViolations(snapshot, config, graphData) {
-  const violations = [];
-  const thresholds = {
+function resolveThresholds(config) {
+  const userThresholds = config?.thresholds;
+  if (!userThresholds) return { ...DEFAULT_THRESHOLDS };
+  return {
     cyclomaticComplexity: {
-      error: config?.thresholds?.cyclomaticComplexity?.error ?? DEFAULT_THRESHOLDS.cyclomaticComplexity.error,
-      warn: config?.thresholds?.cyclomaticComplexity?.warn ?? DEFAULT_THRESHOLDS.cyclomaticComplexity.warn
+      ...DEFAULT_THRESHOLDS.cyclomaticComplexity,
+      ...stripUndefined(userThresholds.cyclomaticComplexity)
     },
     nestingDepth: {
-      warn: config?.thresholds?.nestingDepth?.warn ?? DEFAULT_THRESHOLDS.nestingDepth.warn
+      ...DEFAULT_THRESHOLDS.nestingDepth,
+      ...stripUndefined(userThresholds.nestingDepth)
     },
     functionLength: {
-      warn: config?.thresholds?.functionLength?.warn ?? DEFAULT_THRESHOLDS.functionLength.warn
+      ...DEFAULT_THRESHOLDS.functionLength,
+      ...stripUndefined(userThresholds.functionLength)
     },
     parameterCount: {
-      warn: config?.thresholds?.parameterCount?.warn ?? DEFAULT_THRESHOLDS.parameterCount.warn
+      ...DEFAULT_THRESHOLDS.parameterCount,
+      ...stripUndefined(userThresholds.parameterCount)
     },
-    fileLength: {
-      info: config?.thresholds?.fileLength?.info ?? DEFAULT_THRESHOLDS.fileLength.info
-    }
+    fileLength: { ...DEFAULT_THRESHOLDS.fileLength, ...stripUndefined(userThresholds.fileLength) }
   };
+}
+function stripUndefined(obj) {
+  if (!obj) return {};
+  const result = {};
+  for (const [key, val] of Object.entries(obj)) {
+    if (val !== void 0) result[key] = val;
+  }
+  return result;
+}
+function checkFileLengthViolation(filePath, lineCount, threshold) {
+  if (lineCount <= threshold) return null;
+  return {
+    file: filePath,
+    function: "<file>",
+    line: 1,
+    metric: "fileLength",
+    value: lineCount,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `File has ${lineCount} lines (threshold: ${threshold})`
+  };
+}
+function checkCyclomaticComplexity(filePath, fn, thresholds) {
+  const complexity = computeCyclomaticComplexity(fn.body);
+  if (complexity > thresholds.error) {
+    return {
+      file: filePath,
+      function: fn.name,
+      line: fn.line,
+      metric: "cyclomaticComplexity",
+      value: complexity,
+      threshold: thresholds.error,
+      tier: 1,
+      severity: "error",
+      message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (error threshold: ${thresholds.error})`
+    };
+  }
+  if (complexity > thresholds.warn) {
+    return {
+      file: filePath,
+      function: fn.name,
+      line: fn.line,
+      metric: "cyclomaticComplexity",
+      value: complexity,
+      threshold: thresholds.warn,
+      tier: 2,
+      severity: "warning",
+      message: `Function "${fn.name}" has cyclomatic complexity of ${complexity} (warning threshold: ${thresholds.warn})`
+    };
+  }
+  return null;
+}
+function checkNestingDepth(filePath, fn, threshold) {
+  const depth = computeNestingDepth(fn.body);
+  if (depth <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "nestingDepth",
+    value: depth,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" has nesting depth of ${depth} (threshold: ${threshold})`
+  };
+}
+function checkFunctionLength(filePath, fn, threshold) {
+  const fnLength = fn.endLine - fn.startLine + 1;
+  if (fnLength <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "functionLength",
+    value: fnLength,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" is ${fnLength} lines long (threshold: ${threshold})`
+  };
+}
+function checkParameterCount(filePath, fn, threshold) {
+  if (fn.params <= threshold) return null;
+  return {
+    file: filePath,
+    function: fn.name,
+    line: fn.line,
+    metric: "parameterCount",
+    value: fn.params,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Function "${fn.name}" has ${fn.params} parameters (threshold: ${threshold})`
+  };
+}
+function checkHotspot(filePath, fn, graphData) {
+  const hotspot = graphData.hotspots.find((h) => h.file === filePath && h.function === fn.name);
+  if (!hotspot || hotspot.hotspotScore <= graphData.percentile95Score) return null;
+  return {
+    file: filePath,
+    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})`
+  };
+}
+function collectFunctionViolations(filePath, fn, thresholds, graphData) {
+  const checks = [
+    checkCyclomaticComplexity(filePath, fn, thresholds.cyclomaticComplexity),
+    checkNestingDepth(filePath, fn, thresholds.nestingDepth.warn),
+    checkFunctionLength(filePath, fn, thresholds.functionLength.warn),
+    checkParameterCount(filePath, fn, thresholds.parameterCount.warn)
+  ];
+  if (graphData) {
+    checks.push(checkHotspot(filePath, fn, graphData));
+  }
+  return checks.filter((v) => v !== null);
+}
+async function detectComplexityViolations(snapshot, config, graphData) {
+  const violations = [];
+  const thresholds = resolveThresholds(config);
   let totalFunctions = 0;
   for (const file of snapshot.files) {
     let content;
@@ -815,107 +954,16 @@ async function detectComplexityViolations(snapshot, config, graphData) {
       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 fileLenViolation = checkFileLengthViolation(
+      file.path,
+      lines.length,
+      thresholds.fileLength.info
+    );
+    if (fileLenViolation) violations.push(fileLenViolation);
     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})`
-          });
-        }
-      }
+      violations.push(...collectFunctionViolations(file.path, fn, thresholds, graphData));
     }
   }
   const errorCount = violations.filter((v) => v.severity === "error").length;
@@ -995,7 +1043,7 @@ var ComplexityCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = (0, import_node_path4.relative)(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}:${v.function}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1020,9 +1068,6 @@ var ComplexityCollector = class {
   }
 };
 
-// src/architecture/collectors/coupling.ts
-var import_node_path5 = require("path");
-
 // src/entropy/detectors/coupling.ts
 var DEFAULT_THRESHOLDS2 = {
   fanOut: { warn: 15 },
@@ -1224,7 +1269,7 @@ var CouplingCollector = class {
       (v) => v.severity === "error" || v.severity === "warning"
     );
     const violations = filtered.map((v) => {
-      const relFile = (0, import_node_path5.relative)(rootDir, v.file);
+      const relFile = relativePosix(rootDir, v.file);
       const idDetail = `${v.metric}`;
       return {
         id: violationId(relFile, this.category, idDetail),
@@ -1247,7 +1292,6 @@ var CouplingCollector = class {
 };
 
 // src/architecture/collectors/forbidden-imports.ts
-var import_node_path6 = require("path");
 var ForbiddenImportCollector = class {
   category = "forbidden-imports";
   getRules(_config, _rootDir) {
@@ -1291,8 +1335,8 @@ var ForbiddenImportCollector = class {
       (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 relFile = relativePosix(rootDir, v.file);
+      const relImport = relativePosix(rootDir, v.imports);
       const detail = `forbidden import: ${relFile} -> ${relImport}`;
       return {
         id: violationId(relFile, this.category, detail),
@@ -1315,7 +1359,7 @@ var ForbiddenImportCollector = class {
 
 // src/architecture/collectors/module-size.ts
 var import_promises2 = require("fs/promises");
-var import_node_path7 = require("path");
+var import_node_path3 = require("path");
 async function discoverModules(rootDir) {
   const modules = [];
   async function scanDir(dir) {
@@ -1331,7 +1375,7 @@ async function discoverModules(rootDir) {
       if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
         continue;
       }
-      const fullPath = (0, import_node_path7.join)(dir, entry.name);
+      const fullPath = (0, import_node_path3.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")) {
@@ -1348,10 +1392,10 @@ async function discoverModules(rootDir) {
         }
       }
       modules.push({
-        modulePath: (0, import_node_path7.relative)(rootDir, dir),
+        modulePath: relativePosix(rootDir, dir),
         fileCount: tsFiles.length,
         totalLoc,
-        files: tsFiles.map((f) => (0, import_node_path7.relative)(rootDir, f))
+        files: tsFiles.map((f) => relativePosix(rootDir, f))
       });
     }
     for (const sub of subdirs) {
@@ -1443,16 +1487,16 @@ var ModuleSizeCollector = class {
 
 // src/architecture/collectors/dep-depth.ts
 var import_promises3 = require("fs/promises");
-var import_node_path8 = require("path");
+var import_node_path4 = 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);
+  const dir = (0, import_node_path4.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]);
+      let resolved = (0, import_node_path4.resolve)(dir, match[1]);
       if (!resolved.endsWith(".ts") && !resolved.endsWith(".tsx")) {
         resolved += ".ts";
       }
@@ -1473,7 +1517,7 @@ async function collectTsFiles(dir) {
     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);
+      const fullPath = (0, import_node_path4.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")) {
@@ -1527,7 +1571,7 @@ var DepDepthCollector = class {
     }
     const moduleMap = /* @__PURE__ */ new Map();
     for (const file of allFiles) {
-      const relDir = (0, import_node_path8.relative)(rootDir, (0, import_node_path8.dirname)(file));
+      const relDir = relativePosix(rootDir, (0, import_node_path4.dirname)(file));
       if (!moduleMap.has(relDir)) moduleMap.set(relDir, []);
       moduleMap.get(relDir).push(file);
     }