@harness-engineering/core 0.21.1 → 0.21.3

package/dist/{chunk-BQUWXBGR.mjs → chunk-4W4FRAA6.mjs}

@@ -389,6 +389,28 @@ async function detectCircularDepsInFiles(files, parser, graphDependencyData) {
 }
 
 // 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) {
@@ -404,21 +426,7 @@ var CircularDepsCollector = class {
   }
   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);
+    const graphResult = await buildDependencyGraph(files, makeStubParser());
     if (!graphResult.ok) {
       return [
         {
@@ -443,16 +451,7 @@ var CircularDepsCollector = class {
       ];
     }
     const { cycles, largestCycle } = result.value;
-    const violations = cycles.map((cycle) => {
-      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,
-        detail: `Circular dependency: ${cyclePath}`,
-        severity: cycle.severity
-      };
-    });
+    const violations = mapCycleViolations(cycles, rootDir, this.category);
     return [
       {
         category: this.category,
@@ -466,6 +465,30 @@ var CircularDepsCollector = class {
 };
 
 // src/architecture/collectors/layer-violations.ts
+function makeLayerStubParser() {
+  return {
+    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 } })
+  };
+}
+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) {
@@ -480,18 +503,10 @@ var LayerViolationCollector = class {
     ];
   }
   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,
+      parser: makeLayerStubParser(),
       fallbackBehavior: "skip"
     });
     if (!result.ok) {
@@ -505,29 +520,12 @@ var LayerViolationCollector = class {
         }
       ];
     }
-    const layerViolations = result.value.violations.filter(
-      (v) => v.reason === "WRONG_LAYER"
+    const violations = mapLayerViolations(
+      result.value.violations.filter((v) => v.reason === "WRONG_LAYER"),
+      rootDir,
+      this.category
     );
-    const violations = 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, this.category, detail),
-        file: relFile,
-        category: this.category,
-        detail,
-        severity: "error"
-      };
-    });
-    return [
-      {
-        category: this.category,
-        scope: "project",
-        value: violations.length,
-        violations
-      }
-    ];
+    return [{ category: this.category, scope: "project", value: violations.length, violations }];
   }
 };
 
@@ -651,39 +649,43 @@ function collectOrphanedBaselineViolations(baseline, visitedCategories) {
   }
   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 newViolations = [];
-  const resolvedViolations = [];
-  const preExisting = [];
-  const regressions = [];
+  const acc = {
+    newViolations: [],
+    resolvedViolations: [],
+    preExisting: [],
+    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;
-    const classified = classifyViolations(agg.violations, baselineViolationIds);
-    newViolations.push(...classified.newViolations);
-    preExisting.push(...classified.preExisting);
-    const currentViolationIds = new Set(agg.violations.map((v) => v.id));
-    resolvedViolations.push(...findResolvedViolations(baselineCategory, currentViolationIds));
-    if (baselineCategory && agg.value > baselineValue) {
-      regressions.push({
-        category,
-        baselineValue,
-        currentValue: agg.value,
-        delta: agg.value - baselineValue
-      });
-    }
+    diffCategory(category, agg, baseline.metrics[category], acc);
   }
-  resolvedViolations.push(...collectOrphanedBaselineViolations(baseline, visitedCategories));
+  acc.resolvedViolations.push(...collectOrphanedBaselineViolations(baseline, visitedCategories));
   return {
-    passed: newViolations.length === 0 && regressions.length === 0,
-    newViolations,
-    resolvedViolations,
-    preExisting,
-    regressions
+    passed: acc.newViolations.length === 0 && acc.regressions.length === 0,
+    newViolations: acc.newViolations,
+    resolvedViolations: acc.resolvedViolations,
+    preExisting: acc.preExisting,
+    regressions: acc.regressions
   };
 }
 
@@ -753,26 +755,28 @@ function findFunctionEnd(lines, startIdx) {
   }
   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) {
+var DECISION_PATTERNS = [
+  /\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
+];
+function countDecisionPoints(body) {
+  let count = 0;
+  for (const pattern of DECISION_PATTERNS) {
     const matches = body.match(pattern);
-    if (matches) {
-      complexity += matches.length;
-    }
+    if (matches) count += matches.length;
   }
+  return count;
+}
+function computeCyclomaticComplexity(body) {
+  let complexity = 1 + countDecisionPoints(body);
   const elseIfMatches = body.match(/\belse\s+if\s*\(/g);
   if (elseIfMatches) {
     complexity -= elseIfMatches.length;
@@ -988,6 +992,42 @@ async function detectComplexityViolations(snapshot, config, graphData) {
 }
 
 // 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) {
@@ -1003,32 +1043,11 @@ var ComplexityCollector = class {
   }
   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 snapshot = buildSnapshot(files, rootDir);
+    const maxComplexity = resolveMaxComplexity(_config);
     const complexityConfig = {
       thresholds: {
-        cyclomaticComplexity: {
-          error: maxComplexity,
-          warn: Math.floor(maxComplexity * 0.7)
-        }
+        cyclomaticComplexity: { error: maxComplexity, warn: Math.floor(maxComplexity * 0.7) }
       }
     };
     const result = await detectComplexityViolations(snapshot, complexityConfig);
@@ -1044,20 +1063,7 @@ var ComplexityCollector = class {
       ];
     }
     const { violations: complexityViolations, stats } = result.value;
-    const filtered = complexityViolations.filter(
-      (v) => v.severity === "error" || v.severity === "warning"
-    );
-    const violations = filtered.map((v) => {
-      const relFile = relativePosix(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
-      };
-    });
+    const violations = mapComplexityViolations(complexityViolations, rootDir, this.category);
     return [
       {
         category: this.category,
@@ -1136,8 +1142,8 @@ function resolveImportSource(source, fromFile, snapshot) {
   }
   return void 0;
 }
-function checkViolations(metrics, config) {
-  const thresholds = {
+function resolveThresholds2(config) {
+  return {
     fanOut: { ...DEFAULT_THRESHOLDS2.fanOut, ...config?.thresholds?.fanOut },
     fanIn: { ...DEFAULT_THRESHOLDS2.fanIn, ...config?.thresholds?.fanIn },
     couplingRatio: { ...DEFAULT_THRESHOLDS2.couplingRatio, ...config?.thresholds?.couplingRatio },
@@ -1146,53 +1152,70 @@ function checkViolations(metrics, config) {
       ...config?.thresholds?.transitiveDependencyDepth
     }
   };
+}
+function checkFanOut(m, threshold) {
+  if (m.fanOut <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "fanOut",
+    value: m.fanOut,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `File has ${m.fanOut} imports (threshold: ${threshold})`
+  };
+}
+function checkFanIn(m, threshold) {
+  if (m.fanIn <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "fanIn",
+    value: m.fanIn,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `File is imported by ${m.fanIn} files (threshold: ${threshold})`
+  };
+}
+function checkCouplingRatio(m, threshold) {
+  const totalConnections = m.fanIn + m.fanOut;
+  if (totalConnections <= 5 || m.couplingRatio <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "couplingRatio",
+    value: m.couplingRatio,
+    threshold,
+    tier: 2,
+    severity: "warning",
+    message: `Coupling ratio is ${m.couplingRatio.toFixed(2)} (threshold: ${threshold})`
+  };
+}
+function checkTransitiveDepth(m, threshold) {
+  if (m.transitiveDepth <= threshold) return null;
+  return {
+    file: m.file,
+    metric: "transitiveDependencyDepth",
+    value: m.transitiveDepth,
+    threshold,
+    tier: 3,
+    severity: "info",
+    message: `Transitive dependency depth is ${m.transitiveDepth} (threshold: ${threshold})`
+  };
+}
+function checkMetricViolations(m, thresholds) {
+  const candidates = [
+    checkFanOut(m, thresholds.fanOut.warn),
+    checkFanIn(m, thresholds.fanIn.info),
+    checkCouplingRatio(m, thresholds.couplingRatio.warn),
+    checkTransitiveDepth(m, thresholds.transitiveDependencyDepth.info)
+  ];
+  return candidates.filter((v) => v !== null);
+}
+function checkViolations(metrics, config) {
+  const thresholds = resolveThresholds2(config);
   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})`
-      });
-    }
+    violations.push(...checkMetricViolations(m, thresholds));
   }
   return violations;
 }
@@ -1224,6 +1247,38 @@ async function detectCouplingViolations(snapshot, config, graphData) {
 }
 
 // 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) {
@@ -1239,24 +1294,7 @@ var CouplingCollector = class {
   }
   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 snapshot = buildCouplingSnapshot(files, rootDir);
     const result = await detectCouplingViolations(snapshot);
     if (!result.ok) {
       return [
@@ -1270,20 +1308,7 @@ var CouplingCollector = class {
       ];
     }
     const { violations: couplingViolations, stats } = result.value;
-    const filtered = couplingViolations.filter(
-      (v) => v.severity === "error" || v.severity === "warning"
-    );
-    const violations = filtered.map((v) => {
-      const relFile = relativePosix(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
-      };
-    });
+    const violations = mapCouplingViolations(couplingViolations, rootDir, this.category);
     return [
       {
         category: this.category,
@@ -1297,6 +1322,30 @@ var CouplingCollector = class {
 };
 
 // src/architecture/collectors/forbidden-imports.ts
+function makeForbiddenStubParser() {
+  return {
+    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 } })
+  };
+}
+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) {
@@ -1311,18 +1360,10 @@ var ForbiddenImportCollector = class {
     ];
   }
   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,
+      parser: makeForbiddenStubParser(),
       fallbackBehavior: "skip"
     });
     if (!result.ok) {
@@ -1336,91 +1377,94 @@ var ForbiddenImportCollector = class {
         }
       ];
     }
-    const forbidden = result.value.violations.filter(
-      (v) => v.reason === "FORBIDDEN_IMPORT"
+    const violations = mapForbiddenImportViolations(
+      result.value.violations.filter((v) => v.reason === "FORBIDDEN_IMPORT"),
+      rootDir,
+      this.category
     );
-    const violations = 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, this.category, detail),
-        file: relFile,
-        category: this.category,
-        detail,
-        severity: "error"
-      };
-    });
-    return [
-      {
-        category: this.category,
-        scope: "project",
-        value: violations.length,
-        violations
-      }
-    ];
+    return [{ category: this.category, scope: "project", value: violations.length, violations }];
   }
 };
 
 // src/architecture/collectors/module-size.ts
 import { readFile as readFile3, readdir } from "fs/promises";
 import { join as join2 } from "path";
-async function discoverModules(rootDir) {
-  const modules = [];
-  async function scanDir(dir) {
-    let entries;
-    try {
-      entries = await 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 = join2(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 readFile3(f, "utf-8");
-          totalLoc += content.split("\n").filter((line) => line.trim().length > 0).length;
-        } catch {
-        }
-      }
-      modules.push({
-        modulePath: relativePosix(rootDir, dir),
-        fileCount: tsFiles.length,
-        totalLoc,
-        files: tsFiles.map((f) => relativePosix(rootDir, f))
-      });
+function isSkippedEntry(name) {
+  return name.startsWith(".") || name === "node_modules" || name === "dist";
+}
+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 readFile3(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;
     }
-    for (const sub of subdirs) {
-      await scanDir(sub);
+    if (entry.isFile() && isTsSourceFile(entry.name)) {
+      tsFiles.push(fullPath);
     }
   }
-  await scanDir(rootDir);
+  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 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 { maxLoc, maxFiles } = extractThresholds(config);
     const rules = [];
     if (maxLoc < Infinity) {
       const desc = `Module LOC must not exceed ${maxLoc}`;
@@ -1453,14 +1497,7 @@ var ModuleSizeCollector = class {
   }
   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;
-    }
+    const { maxLoc, maxFiles } = extractThresholds(config);
     return modules.map((mod) => {
       const violations = [];
       if (mod.totalLoc > maxLoc) {
@@ -1510,27 +1547,33 @@ function extractImportSources(content, filePath) {
   }
   return sources;
 }
-async function collectTsFiles(dir) {
-  const results = [];
-  async function scan(d) {
-    let entries;
-    try {
-      entries = await readdir2(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist")
-        continue;
-      const fullPath = join3(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);
-      }
+function isSkippedEntry2(name) {
+  return name.startsWith(".") || name === "node_modules" || name === "dist";
+}
+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);
     }
   }
-  await scan(dir);
+}
+async function collectTsFiles(dir) {
+  const results = [];
+  await scanDir2(dir, results);
   return results;
 }
 function computeLongestChain(file, graph, visited, memo) {
@@ -1561,34 +1604,42 @@ var DepDepthCollector = class {
       }
     ];
   }
-  async collect(config, rootDir) {
-    const allFiles = await collectTsFiles(rootDir);
+  async buildImportGraph(allFiles) {
     const graph = /* @__PURE__ */ new Map();
     const fileSet = new Set(allFiles);
     for (const file of allFiles) {
       try {
         const content = await readFile4(file, "utf-8");
-        const imports = extractImportSources(content, file).filter((imp) => fileSet.has(imp));
-        graph.set(file, imports);
+        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, dirname3(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) {
-      let longestChain = 0;
-      for (const file of files) {
-        const depth = computeLongestChain(file, graph, /* @__PURE__ */ new Set(), memo);
-        if (depth > longestChain) longestChain = depth;
-      }
+      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({