@girardelli/architect-core 8.1.0

package/dist/tests/scorer.test.js

@@ -0,0 +1,610 @@
+import { ArchitectureScorer } from '../src/core/scorer.js';
+describe('ArchitectureScorer', () => {
+    const scorer = new ArchitectureScorer();
+    const mockEdges = [
+        { from: 'src/a.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+        { from: 'src/b.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+        { from: 'src/c.ts', to: 'src/d.ts', type: 'import', weight: 1 },
+    ];
+    const mockAntiPatterns = [
+        {
+            name: 'God Class',
+            severity: 'CRITICAL',
+            location: 'src/Manager.ts',
+            description: 'Test',
+            suggestion: 'Test',
+        },
+    ];
+    describe('score', () => {
+        it('should return a score between 0 and 100', () => {
+            const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+            expect(result.overall).toBeGreaterThanOrEqual(0);
+            expect(result.overall).toBeLessThanOrEqual(100);
+        });
+        it('should calculate component scores', () => {
+            const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+            expect(result.components).toBeDefined();
+            expect(result.components.length).toBeGreaterThan(0);
+            for (const component of result.components) {
+                expect(component.score).toBeGreaterThanOrEqual(0);
+                expect(component.score).toBeLessThanOrEqual(100);
+                expect(component.weight).toBeGreaterThan(0);
+            }
+        });
+        it('should provide breakdown of component scores', () => {
+            const result = scorer.score(mockEdges, mockAntiPatterns, 50);
+            expect(result.breakdown).toBeDefined();
+            expect(result.breakdown.modularity).toBeGreaterThanOrEqual(0);
+            expect(result.breakdown.coupling).toBeGreaterThanOrEqual(0);
+            expect(result.breakdown.cohesion).toBeGreaterThanOrEqual(0);
+            expect(result.breakdown.layering).toBeGreaterThanOrEqual(0);
+        });
+        it('should handle empty edges', () => {
+            const result = scorer.score([], mockAntiPatterns, 10);
+            expect(result.overall).toBeGreaterThanOrEqual(0);
+            expect(result.overall).toBeLessThanOrEqual(100);
+        });
+        it('should penalize anti-patterns in layering score', () => {
+            const lotsOfPatterns = Array(10)
+                .fill(null)
+                .map((_, i) => ({
+                name: 'Test Pattern',
+                severity: 'HIGH',
+                location: `src/file${i}.ts`,
+                description: 'Test',
+                suggestion: 'Test',
+            }));
+            const resultWithPatterns = scorer.score(mockEdges, lotsOfPatterns, 50);
+            const resultWithoutPatterns = scorer.score(mockEdges, [], 50);
+            expect(resultWithPatterns.breakdown.layering).toBeLessThanOrEqual(resultWithoutPatterns.breakdown.layering);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // MODULARITY TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('calculateModularity', () => {
+        it('should score 50 when totalFiles is 0', () => {
+            const result = scorer.score([], [], 0);
+            expect(result.breakdown.modularity).toBe(50);
+        });
+        it('should score 95 when avgEdgesPerFile < 2', () => {
+            // 1 file, 1 edge → avgEdgesPerFile = 1
+            const edges = [
+                { from: 'src/a.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 1);
+            expect(result.breakdown.modularity).toBe(100);
+        });
+        it('should score 85 when avgEdgesPerFile is 2-4', () => {
+            // 2 files, 5 edges → avgEdgesPerFile = 2.5
+            const edges = [
+                { from: 'src/a.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+                { from: 'src/b.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+                { from: 'src/c.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/a.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+                { from: 'src/b.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            expect(result.breakdown.modularity).toBe(85);
+        });
+        it('should score 70 when avgEdgesPerFile is 4-6', () => {
+            // 2 files, 10 edges → avgEdgesPerFile = 5
+            const edges = Array(10)
+                .fill(null)
+                .map((_, _i) => ({
+                from: `src/a.ts`,
+                to: `src/b.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 2);
+            expect(result.breakdown.modularity).toBe(70);
+        });
+        it('should score 50 when avgEdgesPerFile is 6-10', () => {
+            // 2 files, 18 edges → avgEdgesPerFile = 9
+            const edges = Array(18)
+                .fill(null)
+                .map((_, i) => ({
+                from: i % 2 === 0 ? 'src/a.ts' : 'src/b.ts',
+                to: i % 2 === 0 ? 'src/b.ts' : 'src/a.ts',
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 2);
+            expect(result.breakdown.modularity).toBe(50);
+        });
+        it('should score 30 when avgEdgesPerFile >= 10', () => {
+            // 1 file, 10+ edges
+            const edges = Array(11)
+                .fill(null)
+                .map((_, i) => ({
+                from: 'src/a.ts',
+                to: `src/file${i}.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 1);
+            expect(result.breakdown.modularity).toBe(30);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // COUPLING TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('calculateCoupling', () => {
+        it('should score 50 when totalFiles is 0', () => {
+            const result = scorer.score([], [], 0);
+            expect(result.breakdown.coupling).toBe(50);
+        });
+        it('should score 50 when totalFiles is 1', () => {
+            const edges = [
+                { from: 'src/a.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 1);
+            expect(result.breakdown.coupling).toBe(50);
+        });
+        it('should score 95 when couplingRatio < 0.15', () => {
+            // 20 files, 1 file has 2 edges → ratio = 2/19 ≈ 0.105
+            const edges = [
+                { from: 'src/hub.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+                { from: 'src/c.ts', to: 'src/d.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 20);
+            expect(result.breakdown.coupling).toBe(100);
+        });
+        it('should score 85 when couplingRatio is 0.15-0.25', () => {
+            // 10 files, hub has 2 edges → ratio = 2/9 ≈ 0.222
+            const edges = [
+                { from: 'src/hub.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(85);
+        });
+        it('should score 75 when couplingRatio is 0.25-0.35', () => {
+            // 10 files, hub has 3 edges → ratio = 3/9 ≈ 0.333
+            const edges = [
+                { from: 'src/hub.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(75);
+        });
+        it('should score 65 when couplingRatio is 0.35-0.5', () => {
+            // 10 files, hub has 4 edges → ratio = 4/9 ≈ 0.444
+            const edges = [
+                { from: 'src/hub.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/d.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(65);
+        });
+        it('should score 50 when couplingRatio is 0.5-0.7', () => {
+            // 10 files, hub has 6 edges → ratio = 6/9 ≈ 0.667
+            const edges = Array(6)
+                .fill(null)
+                .map((_, i) => ({
+                from: 'src/hub.ts',
+                to: `src/file${i}.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(50);
+        });
+        it('should score 35 when couplingRatio is 0.7-0.85', () => {
+            // 10 files, hub has 7 edges → ratio = 7/9 ≈ 0.778
+            const edges = Array(7)
+                .fill(null)
+                .map((_, i) => ({
+                from: 'src/hub.ts',
+                to: `src/file${i}.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(35);
+        });
+        it('should score 20 when couplingRatio >= 0.85', () => {
+            // 10 files, hub has 8 edges → ratio = 8/9 ≈ 0.889
+            const edges = Array(8)
+                .fill(null)
+                .map((_, i) => ({
+                from: 'src/hub.ts',
+                to: `src/file${i}.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(20);
+        });
+        it('should exclude barrel files (index.ts) from coupling calculation', () => {
+            // Barrel files should not count toward maxEdgeCount
+            const edges = [
+                { from: 'src/index.ts', to: 'src/a.ts', type: 'import', weight: 1 },
+                { from: 'src/index.ts', to: 'src/b.ts', type: 'import', weight: 1 },
+                { from: 'src/index.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/x.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            // Only hub.ts (1 edge) should count, ratio = 1/9
+            expect(result.breakdown.coupling).toBe(100);
+        });
+        it('should exclude barrel files (__init__.py) from coupling calculation', () => {
+            const edges = [
+                { from: 'src/__init__.py', to: 'src/a.py', type: 'import', weight: 1 },
+                { from: 'src/__init__.py', to: 'src/b.py', type: 'import', weight: 1 },
+                { from: 'src/__init__.py', to: 'src/c.py', type: 'import', weight: 1 },
+                { from: 'src/__init__.py', to: 'src/d.py', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            // All edges from __init__.py should be filtered
+            expect(result.breakdown.coupling).toBe(100);
+        });
+        it('should exclude barrel files (mod.rs) from coupling calculation', () => {
+            const edges = [
+                { from: 'src/mod.rs', to: 'src/a.rs', type: 'import', weight: 1 },
+                { from: 'src/mod.rs', to: 'src/b.rs', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(100);
+        });
+        it('should exclude barrel files (__init__.pyi) from coupling calculation', () => {
+            const edges = [
+                { from: 'src/__init__.pyi', to: 'src/a.pyi', type: 'import', weight: 1 },
+                { from: 'src/__init__.pyi', to: 'src/b.pyi', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(100);
+        });
+        it('should exclude barrel files as destinations', () => {
+            // When the destination is index.ts, it should not count
+            const edges = [
+                { from: 'src/a.ts', to: 'src/index.ts', type: 'import', weight: 1 },
+                { from: 'src/b.ts', to: 'src/index.ts', type: 'import', weight: 1 },
+                { from: 'src/hub.ts', to: 'src/c.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 10);
+            expect(result.breakdown.coupling).toBe(100);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // COHESION TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('calculateCohesion', () => {
+        it('should score 50 when there are no edges', () => {
+            const result = scorer.score([], [], 10);
+            expect(result.breakdown.cohesion).toBe(50);
+        });
+        it('should score 95 when cohesionRatio > 0.8', () => {
+            // 10 edges, 9 internal → ratio = 0.9
+            const edges = [
+                // Same package → internal
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                { from: 'api/b.ts', to: 'api/c.ts', type: 'import', weight: 1 },
+                { from: 'api/c.ts', to: 'api/d.ts', type: 'import', weight: 1 },
+                { from: 'api/d.ts', to: 'api/e.ts', type: 'import', weight: 1 },
+                { from: 'api/e.ts', to: 'api/f.ts', type: 'import', weight: 1 },
+                { from: 'api/f.ts', to: 'api/g.ts', type: 'import', weight: 1 },
+                { from: 'api/g.ts', to: 'api/h.ts', type: 'import', weight: 1 },
+                { from: 'api/h.ts', to: 'api/i.ts', type: 'import', weight: 1 },
+                { from: 'api/i.ts', to: 'api/j.ts', type: 'import', weight: 1 },
+                // 1 external
+                { from: 'api/k.ts', to: 'service/x.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(100);
+        });
+        it('should score 85 when cohesionRatio is 0.6-0.8', () => {
+            // 10 edges, 7 internal → ratio = 0.7
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                { from: 'api/b.ts', to: 'api/c.ts', type: 'import', weight: 1 },
+                { from: 'api/c.ts', to: 'api/d.ts', type: 'import', weight: 1 },
+                { from: 'api/d.ts', to: 'api/e.ts', type: 'import', weight: 1 },
+                { from: 'api/e.ts', to: 'api/f.ts', type: 'import', weight: 1 },
+                { from: 'api/f.ts', to: 'api/g.ts', type: 'import', weight: 1 },
+                { from: 'api/g.ts', to: 'api/h.ts', type: 'import', weight: 1 },
+                // 3 external
+                { from: 'api/x.ts', to: 'service/a.ts', type: 'import', weight: 1 },
+                { from: 'api/y.ts', to: 'service/b.ts', type: 'import', weight: 1 },
+                { from: 'api/z.ts', to: 'service/c.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(85);
+        });
+        it('should score 75 when cohesionRatio is 0.45-0.6', () => {
+            // 10 edges, 5 internal → ratio = 0.5
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                { from: 'api/b.ts', to: 'api/c.ts', type: 'import', weight: 1 },
+                { from: 'api/c.ts', to: 'api/d.ts', type: 'import', weight: 1 },
+                { from: 'api/d.ts', to: 'api/e.ts', type: 'import', weight: 1 },
+                { from: 'api/e.ts', to: 'api/f.ts', type: 'import', weight: 1 },
+                // 5 external
+                { from: 'api/w.ts', to: 'service/a.ts', type: 'import', weight: 1 },
+                { from: 'api/x.ts', to: 'service/b.ts', type: 'import', weight: 1 },
+                { from: 'api/y.ts', to: 'service/c.ts', type: 'import', weight: 1 },
+                { from: 'api/z.ts', to: 'service/d.ts', type: 'import', weight: 1 },
+                { from: 'api/q.ts', to: 'service/e.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(75);
+        });
+        it('should score 65 when cohesionRatio is 0.3-0.45', () => {
+            // 10 edges, 4 internal → ratio = 0.4
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                { from: 'api/b.ts', to: 'api/c.ts', type: 'import', weight: 1 },
+                { from: 'api/c.ts', to: 'api/d.ts', type: 'import', weight: 1 },
+                { from: 'api/d.ts', to: 'api/e.ts', type: 'import', weight: 1 },
+                // 6 external
+                { from: 'api/w.ts', to: 'service/a.ts', type: 'import', weight: 1 },
+                { from: 'api/x.ts', to: 'service/b.ts', type: 'import', weight: 1 },
+                { from: 'api/y.ts', to: 'service/c.ts', type: 'import', weight: 1 },
+                { from: 'api/z.ts', to: 'service/d.ts', type: 'import', weight: 1 },
+                { from: 'api/q.ts', to: 'service/e.ts', type: 'import', weight: 1 },
+                { from: 'api/r.ts', to: 'service/f.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(65);
+        });
+        it('should score 50 when cohesionRatio is 0.15-0.3', () => {
+            // 10 edges, 2 internal → ratio = 0.2
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                { from: 'api/b.ts', to: 'api/c.ts', type: 'import', weight: 1 },
+                // 8 external
+                { from: 'api/v.ts', to: 'service/a.ts', type: 'import', weight: 1 },
+                { from: 'api/w.ts', to: 'service/b.ts', type: 'import', weight: 1 },
+                { from: 'api/x.ts', to: 'service/c.ts', type: 'import', weight: 1 },
+                { from: 'api/y.ts', to: 'service/d.ts', type: 'import', weight: 1 },
+                { from: 'api/z.ts', to: 'service/e.ts', type: 'import', weight: 1 },
+                { from: 'api/q.ts', to: 'service/f.ts', type: 'import', weight: 1 },
+                { from: 'api/r.ts', to: 'service/g.ts', type: 'import', weight: 1 },
+                { from: 'api/s.ts', to: 'service/h.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(50);
+        });
+        it('should score 30 when cohesionRatio <= 0.15', () => {
+            // 10 edges, 1 internal → ratio = 0.1
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+                // 9 external
+                { from: 'api/c.ts', to: 'service/a.ts', type: 'import', weight: 1 },
+                { from: 'api/d.ts', to: 'service/b.ts', type: 'import', weight: 1 },
+                { from: 'api/e.ts', to: 'service/c.ts', type: 'import', weight: 1 },
+                { from: 'api/f.ts', to: 'service/d.ts', type: 'import', weight: 1 },
+                { from: 'api/g.ts', to: 'service/e.ts', type: 'import', weight: 1 },
+                { from: 'api/h.ts', to: 'service/f.ts', type: 'import', weight: 1 },
+                { from: 'api/i.ts', to: 'service/g.ts', type: 'import', weight: 1 },
+                { from: 'api/j.ts', to: 'service/h.ts', type: 'import', weight: 1 },
+                { from: 'api/k.ts', to: 'service/i.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 50);
+            expect(result.breakdown.cohesion).toBe(30);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // INTERNAL DEPENDENCY TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('isInternalDependency', () => {
+        it('should return true when both files are root files (no directory)', () => {
+            const edges = [
+                { from: 'app.ts', to: 'main.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            // Both root → internal → cohesion should be high
+            expect(result.breakdown.cohesion).toBe(100);
+        });
+        it('should return true when files share same top-level directory', () => {
+            const edges = [
+                { from: 'api/routes.ts', to: 'api/handlers.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            // Same package (api) → internal
+            expect(result.breakdown.cohesion).toBe(100);
+        });
+        it('should return false when files are in different top-level directories', () => {
+            const edges = [
+                { from: 'api/routes.ts', to: 'service/handler.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            // Different packages → external
+            expect(result.breakdown.cohesion).toBe(30);
+        });
+        it('should handle Python package structure', () => {
+            const edges = [
+                { from: 'deepguard/cli.py', to: 'deepguard/analyzer.py', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            // Same package → internal
+            expect(result.breakdown.cohesion).toBe(100);
+        });
+        it('should handle deeply nested paths - same top-level package', () => {
+            const edges = [
+                { from: 'mypackage/domain/entities/user.ts', to: 'mypackage/application/services/user.service.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 2);
+            // Both start with mypackage → internal
+            expect(result.breakdown.cohesion).toBe(100);
+        });
+        it('should handle mixed package structures', () => {
+            const edges = [
+                { from: 'pkg1/file.ts', to: 'pkg2/file.ts', type: 'import', weight: 1 },
+                { from: 'pkg1/a.ts', to: 'pkg1/b.ts', type: 'import', weight: 1 },
+            ];
+            const result = scorer.score(edges, [], 4);
+            // 50% internal
+            expect(result.breakdown.cohesion).toBe(75);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // LAYERING TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('calculateLayering', () => {
+        it('should score 95 when there are 0 violations', () => {
+            const antiPatterns = [
+                {
+                    name: 'God Class',
+                    severity: 'CRITICAL',
+                    location: 'src/Manager.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+            ];
+            const result = scorer.score([], antiPatterns, 10);
+            expect(result.breakdown.layering).toBe(100);
+        });
+        it('should score 90 when there is 1 violation in a large project', () => {
+            const antiPatterns = [
+                {
+                    name: 'Leaky Abstraction',
+                    severity: 'HIGH',
+                    location: 'src/api.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+            ];
+            // 1 violation / 100 files = 1% ratio → score 90
+            const result = scorer.score([], antiPatterns, 100);
+            expect(result.breakdown.layering).toBe(95);
+        });
+        it('should score 80 when ratio is between 2-5%', () => {
+            const antiPatterns = [
+                {
+                    name: 'Leaky Abstraction',
+                    severity: 'HIGH',
+                    location: 'src/api.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+                {
+                    name: 'Shotgun Surgery',
+                    severity: 'MEDIUM',
+                    location: 'src/service.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+            ];
+            // 2 violations / 100 files = 2% ratio → score 95
+            const result = scorer.score([], antiPatterns, 100);
+            expect(result.breakdown.layering).toBe(95);
+        });
+        it('should score 85 when ratio is between 5-15%', () => {
+            const antiPatterns = [
+                {
+                    name: 'Leaky Abstraction',
+                    severity: 'HIGH',
+                    location: 'src/api.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+                {
+                    name: 'Shotgun Surgery',
+                    severity: 'MEDIUM',
+                    location: 'src/service.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+                {
+                    name: 'Circular Dependency',
+                    severity: 'CRITICAL',
+                    location: 'src/model.ts',
+                    description: 'Test',
+                    suggestion: 'Test',
+                },
+            ];
+            // 3 violations / 50 files = 6% ratio → score 85
+            const result = scorer.score([], antiPatterns, 50);
+            expect(result.breakdown.layering).toBe(85);
+        });
+        it('should score 85 when ratio is between 10-15%', () => {
+            const antiPatterns = [
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/api.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Shotgun Surgery', severity: 'MEDIUM', location: 'src/service.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Circular Dependency', severity: 'CRITICAL', location: 'src/model.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/data.ts', description: 'Test', suggestion: 'Test' },
+            ];
+            // 4 violations / 30 files = 13.3% ratio → score 85
+            const result = scorer.score([], antiPatterns, 30);
+            expect(result.breakdown.layering).toBe(85);
+        });
+        it('should score 20 when ratio exceeds 60%', () => {
+            const antiPatterns = [
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/a.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Shotgun Surgery', severity: 'MEDIUM', location: 'src/b.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Circular Dependency', severity: 'CRITICAL', location: 'src/c.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/d.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Shotgun Surgery', severity: 'MEDIUM', location: 'src/e.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Circular Dependency', severity: 'CRITICAL', location: 'src/f.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/g.ts', description: 'Test', suggestion: 'Test' },
+            ];
+            // 7 violations / 10 files = 70% ratio → score 20
+            const result = scorer.score([], antiPatterns, 10);
+            expect(result.breakdown.layering).toBe(20);
+        });
+        it('should only count specific violation types', () => {
+            // Only count: 'Leaky Abstraction', 'Shotgun Surgery', 'Circular Dependency'
+            const antiPatterns = [
+                { name: 'God Class', severity: 'CRITICAL', location: 'src/a.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Leaky Abstraction', severity: 'HIGH', location: 'src/b.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Feature Envy', severity: 'MEDIUM', location: 'src/c.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Shotgun Surgery', severity: 'MEDIUM', location: 'src/d.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Long Method', severity: 'LOW', location: 'src/e.ts', description: 'Test', suggestion: 'Test' },
+                { name: 'Circular Dependency', severity: 'CRITICAL', location: 'src/f.ts', description: 'Test', suggestion: 'Test' },
+            ];
+            // Only Leaky Abstraction, Shotgun Surgery, Circular Dependency count = 3
+            // 3 violations / 100 files = 3% ratio → score 95
+            const result = scorer.score([], antiPatterns, 100);
+            expect(result.breakdown.layering).toBe(95);
+        });
+    });
+    // ═══════════════════════════════════════════════════════════════════════
+    // OVERALL SCORE TESTS
+    // ═══════════════════════════════════════════════════════════════════════
+    describe('overall scoring and weighting', () => {
+        it('should compute weighted average correctly', () => {
+            // Create edges for known scores
+            const edges = [
+                { from: 'api/a.ts', to: 'api/b.ts', type: 'import', weight: 1 },
+            ];
+            const antiPatterns = [];
+            const result = scorer.score(edges, antiPatterns, 1);
+            // With 1 file, 1 edge:
+            // modularity = 95 (avgEdgesPerFile = 1)
+            // coupling = 50 (1 totalFile)
+            // cohesion = 95 (internal dependency)
+            // layering = 95 (no violations)
+            // overall = 95*0.4 + 50*0.25 + 95*0.2 + 95*0.15 = 38 + 12.5 + 19 + 14.25 = 83.75 ≈ 84
+            expect(result.overall).toBeGreaterThanOrEqual(83);
+            expect(result.overall).toBeLessThanOrEqual(95);
+        });
+        it('should clamp overall score to [0, 100]', () => {
+            const result = scorer.score([], [], 0);
+            expect(result.overall).toBeGreaterThanOrEqual(0);
+            expect(result.overall).toBeLessThanOrEqual(100);
+        });
+        it('should round component scores', () => {
+            const edges = Array(3)
+                .fill(null)
+                .map((_, i) => ({
+                from: 'a.ts',
+                to: `b${i}.ts`,
+                type: 'import',
+                weight: 1,
+            }));
+            const result = scorer.score(edges, [], 1);
+            // All component scores should be integers
+            expect(Number.isInteger(result.breakdown.modularity)).toBe(true);
+            expect(Number.isInteger(result.breakdown.coupling)).toBe(true);
+            expect(Number.isInteger(result.breakdown.cohesion)).toBe(true);
+            expect(Number.isInteger(result.breakdown.layering)).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=scorer.test.js.map