@girardelli/architect 1.2.0 → 1.3.0

package/src/scorer.ts

@@ -1,4 +1,5 @@
 import { ArchitectureScore, DependencyEdge, AntiPattern, ScoreComponent } from './types.js';
+import { basename } from 'path';
 
 export class ArchitectureScorer {
   private modularity: number = 0;
@@ -6,6 +7,15 @@ export class ArchitectureScorer {
   private cohesion: number = 0;
   private layering: number = 0;
 
+  /**
+   * Barrel/index files that naturally have many connections and should be
+   * excluded from coupling max-edge penalty calculations.
+   */
+  private static readonly BARREL_FILES = new Set([
+    '__init__.py', 'index.ts', 'index.js', 'index.tsx', 'index.jsx',
+    'mod.rs', '__init__.pyi',
+  ]);
+
   score(
     edges: DependencyEdge[],
     antiPatterns: AntiPattern[],
@@ -91,26 +101,42 @@ export class ArchitectureScorer {
   }
 
   private calculateCoupling(edges: DependencyEdge[], totalFiles: number): void {
-    if (totalFiles === 0) {
+    if (totalFiles === 0 || totalFiles === 1) {
       this.coupling = 50;
       return;
     }
 
-    const nodeWithMaxEdges = this.findNodeWithMaxEdges(edges);
+    // Exclude barrel/index files from max-edge calculation —
+    // they naturally have many connections by design.
+    const nonBarrelEdges = edges.filter((e) => {
+      const fromFile = basename(e.from);
+      const toFile = basename(e.to);
+      return !ArchitectureScorer.BARREL_FILES.has(fromFile) &&
+             !ArchitectureScorer.BARREL_FILES.has(toFile);
+    });
+
+    const nodeWithMaxEdges = this.findNodeWithMaxEdges(nonBarrelEdges);
     const maxEdgeCount = nodeWithMaxEdges ? nodeWithMaxEdges.count : 0;
 
-    const couplingRatio = maxEdgeCount / (totalFiles - 1);
+    // Use non-barrel file count for ratio calculation
+    const effectiveFiles = Math.max(totalFiles - 1, 1);
+    const couplingRatio = maxEdgeCount / effectiveFiles;
 
-    if (couplingRatio < 0.2) {
+    // More granular thresholds
+    if (couplingRatio < 0.15) {
       this.coupling = 95;
-    } else if (couplingRatio < 0.4) {
+    } else if (couplingRatio < 0.25) {
       this.coupling = 85;
-    } else if (couplingRatio < 0.6) {
-      this.coupling = 70;
-    } else if (couplingRatio < 0.8) {
+    } else if (couplingRatio < 0.35) {
+      this.coupling = 75;
+    } else if (couplingRatio < 0.5) {
+      this.coupling = 65;
+    } else if (couplingRatio < 0.7) {
       this.coupling = 50;
+    } else if (couplingRatio < 0.85) {
+      this.coupling = 35;
     } else {
-      this.coupling = 30;
+      this.coupling = 20;
     }
   }
 
@@ -149,23 +175,42 @@ export class ArchitectureScorer {
 
     const cohesionRatio = internalEdges / edges.length;
 
-    if (cohesionRatio > 0.7) {
+    // More granular thresholds
+    if (cohesionRatio > 0.8) {
       this.cohesion = 95;
-    } else if (cohesionRatio > 0.5) {
-      this.cohesion = 80;
+    } else if (cohesionRatio > 0.6) {
+      this.cohesion = 85;
+    } else if (cohesionRatio > 0.45) {
+      this.cohesion = 75;
     } else if (cohesionRatio > 0.3) {
       this.cohesion = 65;
-    } else if (cohesionRatio > 0.1) {
-      this.cohesion = 45;
+    } else if (cohesionRatio > 0.15) {
+      this.cohesion = 50;
     } else {
       this.cohesion = 30;
     }
   }
 
+  /**
+   * Determines if a dependency is "internal" (cohesive).
+   * Two files are considered cohesive if they share the same top-level
+   * package/directory (e.g., deepguard/cli.py → deepguard/analyzer.py).
+   * This is crucial for Python flat packages where all files live in
+   * one directory but ARE cohesive.
+   */
   private isInternalDependency(from: string, to: string): boolean {
-    const fromModule = from.split('/').slice(0, -1).join('/');
-    const toModule = to.split('/').slice(0, -1).join('/');
-    return fromModule === toModule;
+    const fromParts = from.split('/');
+    const toParts = to.split('/');
+
+    // If both are in root (no directory), they're cohesive
+    if (fromParts.length <= 1 && toParts.length <= 1) return true;
+
+    // Compare top-level directory (package name)
+    // e.g., "deepguard/cli.py" and "deepguard/analyzer.py" → same package
+    const fromTopLevel = fromParts.length > 1 ? fromParts[0] : '';
+    const toTopLevel = toParts.length > 1 ? toParts[0] : '';
+
+    return fromTopLevel === toTopLevel;
   }
 
   private calculateLayering(antiPatterns: AntiPattern[]): void {
@@ -191,3 +236,4 @@ export class ArchitectureScorer {
     }
   }
 }
+