@girardelli/architect-core 8.1.0

package/src/core/rules/hub-splitter.ts

@@ -0,0 +1,135 @@
+import { basename, dirname} from 'path';
+import { AnalysisReport } from '../types/core.js';
+import { RefactorRule, RefactorStep, FileOperation } from '../types/rules.js';
+
+/**
+ * Hub Splitter Rule (Tier 1)
+ * Detects files with many connections and generates split plans.
+ * A "hub" is a file that many other files depend on, creating tight coupling.
+ */
+export class HubSplitterRule implements RefactorRule {
+  name = 'hub-splitter';
+  tier = 1 as const;
+
+  analyze(report: AnalysisReport, _projectPath: string): RefactorStep[] {
+    const steps: RefactorStep[] = [];
+
+    // Count connections per node
+    const connectionCount: Record<string, { incoming: string[]; outgoing: string[] }> = {};
+
+    for (const edge of report.dependencyGraph.edges) {
+      if (!connectionCount[edge.from]) connectionCount[edge.from] = { incoming: [], outgoing: [] };
+      if (!connectionCount[edge.to]) connectionCount[edge.to] = { incoming: [], outgoing: [] };
+      connectionCount[edge.from].outgoing.push(edge.to);
+      connectionCount[edge.to].incoming.push(edge.from);
+    }
+
+    // Find hubs (5+ incoming connections, not barrel files)
+    const barrelFiles = new Set(['__init__.py', 'index.ts', 'index.js', 'index.tsx', 'mod.rs']);
+
+    for (const [file, connections] of Object.entries(connectionCount)) {
+      const fileName = basename(file);
+      if (barrelFiles.has(fileName)) continue;
+      
+      // Ignora Tipos base/DTOs - Alto acoplamento em tipos é sinal de maturidade, não gargalo
+      const lowerFile = file.toLowerCase();
+      if (lowerFile.includes('types') || lowerFile.includes('interface') || lowerFile.includes('/types/')) {
+        continue;
+      }
+      
+      // Tolerância Arquitetural: Eleva de 5 pra 8 dependentes pra engatilhar quebra (Módulos Coesos maduros)
+      if (connections.incoming.length < 8) continue;
+
+      const operations: FileOperation[] = [];
+
+      // Determine if this is a dot-notation module or a real file
+      const isDotNotation = !file.includes('/') && !file.includes('\\');
+      const moduleName = isDotNotation
+        ? file.split('.').pop() || file
+        : fileName.replace(/\.[^.]+$/, '');
+      const moduleDir = isDotNotation
+        ? file.split('.').slice(0, -1).join('/')
+        : dirname(file);
+      const ext = isDotNotation ? 'py' : (fileName.split('.').pop() || 'py');
+
+      // Analyze what dependents import to suggest groupings
+      const dependentGroups = this.groupDependents(connections.incoming);
+
+      // Suggest splitting into domain modules
+      if (dependentGroups.length >= 2) {
+        for (const group of dependentGroups) {
+          const newFileName = `${moduleName}_${group.name}.${ext}`;
+          const newPath = moduleDir ? `${moduleDir}/${newFileName}` : newFileName;
+
+          operations.push({
+            type: 'CREATE',
+            path: newPath,
+            description: `Create \`${newFileName}\` with functionality used by: ${group.dependents.join(', ')}`,
+            content: ext === 'py'
+              ? `"""${moduleName}_${group.name} — extracted from ${moduleName}."""\n# Used by: ${group.dependents.join(', ')}\n`
+              : `// ${moduleName}_${group.name} — extracted from ${moduleName}\n// Used by: ${group.dependents.join(', ')}\n`,
+          });
+        }
+
+        // Update imports in all dependents
+        for (const dependent of connections.incoming) {
+          operations.push({
+            type: 'MODIFY',
+            path: dependent,
+            description: `Update imports in \`${basename(dependent)}\` to use new split modules`,
+          });
+        }
+
+        // Mark original for refactoring
+        operations.push({
+          type: 'MODIFY',
+          path: isDotNotation ? `${moduleDir}/${moduleName}.${ext}` : file,
+          description: `Refactor \`${moduleName}.${ext}\` — extract grouped functionality to new modules`,
+        });
+      }
+
+      if (operations.length > 0) {
+        steps.push({
+          id: 0,
+          tier: 1,
+          rule: this.name,
+          priority: connections.incoming.length >= 8 ? 'CRITICAL' : 'HIGH',
+          title: `Split hub file: ${moduleName}.${ext}`,
+          description: `\`${file}\` has ${connections.incoming.length} incoming connections. ` +
+            `Split into ${dependentGroups.length} focused modules to reduce coupling.`,
+          rationale: `High fan-in (${connections.incoming.length} files depend on this) creates a bottleneck. ` +
+            `Changes to this file ripple to ${connections.incoming.length} other files. ` +
+            `Splitting by usage pattern reduces blast radius.`,
+          operations,
+          scoreImpact: [
+            { metric: 'coupling', before: report.score.breakdown.coupling, after: Math.min(95, report.score.breakdown.coupling + 15) },
+          ],
+          aiPrompt: `Analyze the file \`${file}\`. Based on its incoming connections, it acts as a coupling bottleneck. Please split this file into the following smaller modules:\n` +
+            dependentGroups.map(g => `- \`${moduleName}_${g.name}.${ext}\`: Extract functionality specific to these dependents: ${g.dependents.join(', ')}`).join('\n') +
+            `\n\nAfter splitting, securely and automatically update all ${connections.incoming.length} dependent files to import from the new specific modules instead of the monolithic \`${moduleName}.${ext}\`. DO NOT remove any functionality, only move it.`,
+        });
+      }
+    }
+
+    return steps;
+  }
+
+  private groupDependents(
+    dependents: string[]
+  ): Array<{ name: string; dependents: string[] }> {
+    // Group by top-level directory
+    const groups: Record<string, string[]> = {};
+
+    for (const dep of dependents) {
+      const parts = dep.includes('/') ? dep.split('/') : dep.split('.');
+      const groupName = parts.length >= 2 ? parts[parts.length - 2] : 'core';
+      if (!groups[groupName]) groups[groupName] = [];
+      groups[groupName].push(basename(dep));
+    }
+
+    return Object.entries(groups).map(([name, deps]) => ({
+      name,
+      dependents: deps,
+    }));
+  }
+}

package/src/core/rules/import-organizer.ts

@@ -0,0 +1,100 @@
+import { basename, dirname } from 'path';
+import { AnalysisReport } from '../types/core.js';
+import { RefactorRule, RefactorStep, FileOperation } from '../types/rules.js';
+
+/**
+ * Import Organizer Rule (Tier 1)
+ * Detects files that import from too many different modules (cross-boundary).
+ * Suggests dependency injection or facade patterns.
+ */
+export class ImportOrganizerRule implements RefactorRule {
+  name = 'import-organizer';
+  tier = 1 as const;
+
+  analyze(report: AnalysisReport, _projectPath: string): RefactorStep[] {
+    const steps: RefactorStep[] = [];
+
+    // Find files that import from many different directories
+    const crossBoundary: Record<string, { targets: Set<string>; dirs: Set<string> }> = {};
+
+    for (const edge of report.dependencyGraph.edges) {
+      const fromDir = dirname(edge.from);
+      const toDir = dirname(edge.to);
+
+      if (!crossBoundary[edge.from]) {
+        crossBoundary[edge.from] = { targets: new Set(), dirs: new Set() };
+      }
+      crossBoundary[edge.from].targets.add(edge.to);
+
+      if (fromDir !== toDir) {
+        crossBoundary[edge.from].dirs.add(toDir);
+      }
+    }
+
+    // Outliers reais espalhados consumindo +5 diretórios. Testa bypass em unit-tests (.test.) naturais de altíssima injeção (mock).
+    const violators = Object.entries(crossBoundary)
+      .filter(([fileName, data]) => data.dirs.size >= 5 && !fileName.includes('.test.'))
+      .sort((a, b) => b[1].dirs.size - a[1].dirs.size);
+
+    for (const [file, data] of violators) {
+      const operations: FileOperation[] = [];
+      const fileName = basename(file);
+      const fileDir = dirname(file);
+
+      // Suggest creating a facade/service layer
+      const ext = fileName.split('.').pop() || 'py';
+      const nameBase = fileName.replace(/\.[^.]+$/, '');
+      const facadePath = `${fileDir}/${nameBase}_deps.${ext}`;
+
+      operations.push({
+        type: 'CREATE',
+        path: facadePath,
+        description: `Create dependency facade \`${basename(facadePath)}\` — centralizes ${data.dirs.size} cross-module imports`,
+        content: this.generateFacadeContent(ext, Array.from(data.targets), Array.from(data.dirs)),
+      });
+
+      operations.push({
+        type: 'MODIFY',
+        path: file,
+        description: `Refactor \`${fileName}\` to import from local facade instead of ${data.dirs.size} different modules`,
+      });
+
+      steps.push({
+        id: 0,
+        tier: 1,
+        rule: this.name,
+        priority: data.dirs.size >= 5 ? 'HIGH' : 'MEDIUM',
+        title: `Reduce cross-boundary imports: ${fileName}`,
+        description: `\`${file}\` imports from ${data.dirs.size} different modules: ` +
+          `${Array.from(data.dirs).map((d) => `\`${d}\``).join(', ')}. ` +
+          `Consider using a facade or dependency injection.`,
+        rationale: `Files with imports scattered across many modules have high afferent coupling. ` +
+          `A facade centralizes these dependencies, making the file easier to test (mock one facade) ` +
+          `and reducing the impact of changes in dependent modules.`,
+        operations,
+        scoreImpact: [
+          { metric: 'cohesion', before: report.score.breakdown.cohesion, after: Math.min(95, report.score.breakdown.cohesion + 5) },
+          { metric: 'coupling', before: report.score.breakdown.coupling, after: Math.min(95, report.score.breakdown.coupling + 5) },
+        ],
+        aiPrompt: `Analyze the file \`${file}\` which currently imports from ${data.dirs.size} cross-boundary distinct directories/modules (${Array.from(data.dirs).join(', ')}).\nPlease refactor this to use the Dependency Injection (DI) or Facade pattern:\n1. Extract these imports into a dedicated file \`${facadePath}\`.\n2. Re-export or bundle them appropriately.\n3. Update \`${file}\` to import strictly from the new \`${facadePath}\` rather than directly reaching into multiple disjointed modules, lowering its afferent coupling.`,
+      });
+    }
+
+    return steps;
+  }
+
+  private generateFacadeContent(ext: string, targets: string[], dirs: string[]): string {
+    if (ext === 'py') {
+      const imports = targets
+        .map((t) => `# from ${t.replace(/\//g, '.')} import ...`)
+        .join('\n');
+      return `"""Dependency facade — centralizes cross-module imports."""\n\n${imports}\n\n# Re-export what ${dirs.length} modules need\n`;
+    }
+
+    // JS/TS
+    const imports = targets
+      .map((t) => `// export { ... } from '${t}';`)
+      .join('\n');
+    return `/**\n * Dependency facade — centralizes cross-module imports.\n */\n\n${imports}\n`;
+  }
+}

package/src/core/rules/module-grouper.ts

@@ -0,0 +1,133 @@
+import { basename, dirname, join } from 'path';
+import { AnalysisReport } from '../types/core.js';
+import { RefactorRule, RefactorStep, FileOperation } from '../types/rules.js';
+
+/**
+ * Module Grouper Rule (Tier 1)
+ * Analyzes which files are frequently imported together and suggests
+ * grouping them into cohesive modules/packages.
+ */
+export class ModuleGrouperRule implements RefactorRule {
+  name = 'module-grouper';
+  tier = 1 as const;
+
+  analyze(report: AnalysisReport, _projectPath: string): RefactorStep[] {
+    const steps: RefactorStep[] = [];
+
+    // Build co-import matrix: which files are imported together?
+    const coImportCount: Record<string, Record<string, number>> = {};
+
+    // For each source file, see what it imports
+    const importsBySource: Record<string, string[]> = {};
+    for (const edge of report.dependencyGraph.edges) {
+      if (!importsBySource[edge.from]) importsBySource[edge.from] = [];
+      importsBySource[edge.from].push(edge.to);
+    }
+
+    // Count co-imports
+    for (const [_source, targets] of Object.entries(importsBySource)) {
+      for (let i = 0; i < targets.length; i++) {
+        for (let j = i + 1; j < targets.length; j++) {
+          const a = targets[i];
+          const b = targets[j];
+          if (!coImportCount[a]) coImportCount[a] = {};
+          if (!coImportCount[b]) coImportCount[b] = {};
+          coImportCount[a][b] = (coImportCount[a][b] || 0) + 1;
+          coImportCount[b][a] = (coImportCount[b][a] || 0) + 1;
+        }
+      }
+    }
+
+    // Find clusters: files that are always imported together
+    const clusters: Array<{ files: string[]; coImportScore: number }> = [];
+    const visited = new Set<string>();
+
+    for (const [fileA, partners] of Object.entries(coImportCount)) {
+      if (visited.has(fileA)) continue;
+
+      const strongPartners = Object.entries(partners)
+        .filter(([_, count]) => count >= 3)
+        .sort((a, b) => b[1] - a[1]);
+
+      if (strongPartners.length >= 2) {
+        const cluster = [fileA, ...strongPartners.map(([f]) => f)];
+        const inSameDir = cluster.every(
+          (f) => dirname(f) === dirname(cluster[0])
+        );
+
+        // Only suggest if NOT already in the same directory
+        if (!inSameDir) {
+          // Arquitetura Limpa: Impede arrastar Módulos Transversais (DTOs/Types) para se tornarem fechados em Pastas de Domínios
+          const hasTypes = cluster.some(f => {
+            const lowerF = f.toLowerCase();
+            return lowerF.includes('types') || lowerF.includes('interface') || lowerF.includes('/types/');
+          });
+          if (hasTypes) continue;
+
+          const score = strongPartners.reduce((sum, [_, c]) => sum + c, 0);
+          clusters.push({ files: cluster, coImportScore: score });
+          cluster.forEach((f) => visited.add(f));
+        }
+      }
+    }
+
+    // Generate steps for each cluster
+    for (const cluster of clusters.slice(0, 3)) {
+      const operations: FileOperation[] = [];
+      const clusterName = this.suggestModuleName(cluster.files);
+      const targetDir = `${dirname(cluster.files[0])}/${clusterName}`;
+
+      // Create new module directory
+      operations.push({
+        type: 'CREATE',
+        path: `${targetDir}/__init__.py`,
+        description: `Create new module \`${clusterName}/\` to group ${cluster.files.length} co-dependent files`,
+        content: `"""Module ${clusterName} — grouped by co-import pattern."""\n`,
+      });
+
+      // Move files
+      for (const file of cluster.files) {
+        const newPath = join(targetDir, basename(file));
+        operations.push({
+          type: 'MOVE',
+          path: file,
+          newPath,
+          description: `Move \`${basename(file)}\` → \`${clusterName}/${basename(file)}\``,
+        });
+      }
+
+      steps.push({
+        id: 0,
+        tier: 1,
+        rule: this.name,
+        priority: 'MEDIUM',
+        title: `Group co-dependent files into \`${clusterName}/\``,
+        description: `Files ${cluster.files.map((f) => `\`${basename(f)}\``).join(', ')} ` +
+          `are frequently imported together (co-import score: ${cluster.coImportScore}). ` +
+          `Grouping them improves cohesion.`,
+        rationale: `Files that are frequently imported together belong in the same module. ` +
+          `This improves discoverability and reduces the cognitive load of understanding ` +
+          `which files work together.`,
+        operations,
+        scoreImpact: [
+          { metric: 'cohesion', before: report.score.breakdown.cohesion, after: Math.min(95, report.score.breakdown.cohesion + 10) },
+          { metric: 'modularity', before: report.score.breakdown.modularity, after: Math.min(95, report.score.breakdown.modularity + 5) },
+        ],
+        aiPrompt: `Analyze the files: ${cluster.files.map(f => `\`${f}\``).join(', ')}.\nThese files are frequently imported together but are currently scattered across different directories.\nPlease refactor to improve cohesion:\n1. Create a new directory named \`${targetDir}\`.\n2. Move these files solidly into this new directory.\n3. Add an index/barrel file if appropriate.\n4. Securely scan the entire project to fix all broken imports resulting from this move.`,
+      });
+    }
+
+    return steps;
+  }
+
+  private suggestModuleName(files: string[]): string {
+    // Try to infer a common theme from filenames
+    const names = files.map((f) => basename(f).replace(/\.[^.]+$/, '').toLowerCase());
+    const commonParts = names[0].split(/[_-]/).filter((part) =>
+      names.every((n) => n.includes(part))
+    );
+
+    if (commonParts.length > 0) return commonParts[0];
+    return 'shared';
+  }
+}

package/src/core/rules-engine.ts

@@ -0,0 +1,100 @@
+import { AnalysisReport } from './types/core.js';
+import { ArchitectRules, RuleViolation, ValidationResult } from './types/architect-rules.js';
+
+export class RulesEngine {
+  public validate(report: AnalysisReport, rules: ArchitectRules): ValidationResult {
+    const violations: RuleViolation[] = [];
+
+    this.checkQualityGates(report, rules, violations);
+    this.checkBoundaries(report, rules, violations);
+
+    return {
+      success: violations.every(v => v.level !== 'error'),
+      violations,
+    };
+  }
+
+  private checkQualityGates(report: AnalysisReport, rules: ArchitectRules, violations: RuleViolation[]) {
+    if (!rules.quality_gates) return;
+
+    const { min_overall_score, max_critical_anti_patterns, max_high_anti_patterns } = rules.quality_gates;
+
+    // 1. Minimum Overall Score (Error)
+    if (min_overall_score !== undefined && report.score.overall < min_overall_score) {
+      violations.push({
+        level: 'error',
+        rule: 'quality_gates.min_overall_score',
+        message: `Overall score (${report.score.overall}) is below the minimum required (${min_overall_score}).`,
+        actual: report.score.overall,
+        expected: min_overall_score,
+      });
+    }
+
+    // 2. Max Critical Anti-Patterns (Error)
+    if (max_critical_anti_patterns !== undefined) {
+      const criticalCount = report.antiPatterns.filter(p => p.severity === 'CRITICAL').length;
+      if (criticalCount > max_critical_anti_patterns) {
+        violations.push({
+          level: 'error',
+          rule: 'quality_gates.max_critical_anti_patterns',
+          message: `Too many CRITICAL anti-patterns detected (${criticalCount}). Maximum allowed is ${max_critical_anti_patterns}.`,
+          actual: criticalCount,
+          expected: max_critical_anti_patterns,
+        });
+      }
+    }
+
+    // 3. Max High Anti-Patterns (Warning)
+    if (max_high_anti_patterns !== undefined) {
+      const highCount = report.antiPatterns.filter(p => p.severity === 'HIGH').length;
+      if (highCount > max_high_anti_patterns) {
+        violations.push({
+          level: 'warning',
+          rule: 'quality_gates.max_high_anti_patterns',
+          message: `High number of HIGH severity anti-patterns (${highCount}). Maximum recommended is ${max_high_anti_patterns}.`,
+          actual: highCount,
+          expected: max_high_anti_patterns,
+        });
+      }
+    }
+  }
+
+  private checkBoundaries(report: AnalysisReport, rules: ArchitectRules, violations: RuleViolation[]) {
+    if (!rules.boundaries) return;
+
+    const { allow_circular_dependencies, banned_imports } = rules.boundaries;
+
+    // 1. Allow Circular Dependencies
+    if (allow_circular_dependencies === false) {
+      const hasCycles = report.antiPatterns.filter(p => p.name === 'Circular Dependency');
+      if (hasCycles.length > 0) {
+        violations.push({
+          level: 'error',
+          rule: 'boundaries.allow_circular_dependencies',
+          message: `Circular dependencies are strictly forbidden, but ${hasCycles.length} were found.`,
+          actual: hasCycles.length,
+          expected: 0,
+        });
+      }
+    }
+
+    // 2. Banned Imports (Checks the AST Dependency Graph edges)
+    if (banned_imports && banned_imports.length > 0) {
+      for (const edge of report.dependencyGraph.edges) {
+        // Look through 'to' targets
+        for (const banned of banned_imports) {
+          if (edge.to.includes(banned)) {
+            // Found a banned import!
+            violations.push({
+              level: 'error',
+              rule: 'boundaries.banned_imports',
+              message: `Banned import detected: File '${edge.from}' imports '${banned}'.`,
+              actual: edge.to,
+              expected: `Not to include ${banned}`,
+            });
+          }
+        }
+      }
+    }
+  }
+}

package/src/core/scorer.ts

@@ -0,0 +1,181 @@
+import { ArchitectureScore, DependencyEdge, AntiPattern} from './types/core.js';
+import { basename } from 'path';
+
+export class ArchitectureScorer {
+  /**
+   * 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', 'types.ts', 'types.js', 'logger.ts', 'logger.js'
+  ]);
+
+  score(
+    edges: DependencyEdge[],
+    antiPatterns: AntiPattern[],
+    totalFiles: number
+  ): ArchitectureScore {
+    const modularity = this.calculateModularity(edges, totalFiles);
+    const coupling = this.calculateCoupling(edges, totalFiles);
+    const cohesion = this.calculateCohesion(edges);
+    const layering = this.calculateLayering(antiPatterns, totalFiles);
+
+    const components = [
+      {
+        name: 'Modularity',
+        score: Math.round(modularity),
+        maxScore: 100,
+        weight: 0.4,
+        explanation: 'Measures appropriate module boundaries and single responsibility principle adherence',
+      },
+      {
+        name: 'Coupling',
+        score: Math.round(coupling),
+        maxScore: 100,
+        weight: 0.25,
+        explanation: 'Evaluates interdependencies between modules; lower coupling is better',
+      },
+      {
+        name: 'Cohesion',
+        score: Math.round(cohesion),
+        maxScore: 100,
+        weight: 0.2,
+        explanation: 'Assesses how closely related functionality is grouped together',
+      },
+      {
+        name: 'Layering',
+        score: Math.round(layering),
+        maxScore: 100,
+        weight: 0.15,
+        explanation: 'Checks adherence to architectural layer separation',
+      },
+    ];
+
+    const overall = Math.round(
+      components[0].score * components[0].weight +
+      components[1].score * components[1].weight +
+      components[2].score * components[2].weight +
+      components[3].score * components[3].weight
+    );
+
+    return {
+      overall: Math.min(100, Math.max(0, overall)),
+      components,
+      breakdown: {
+        modularity: Math.round(modularity),
+        coupling: Math.round(coupling),
+        cohesion: Math.round(cohesion),
+        layering: Math.round(layering),
+      },
+    };
+  }
+
+  private calculateModularity(edges: DependencyEdge[], totalFiles: number): number {
+    if (totalFiles === 0) return 50;
+
+    const avgEdgesPerFile = edges.length / totalFiles;
+
+    if (avgEdgesPerFile < 2) return 100;
+    if (avgEdgesPerFile < 4) return 85;
+    if (avgEdgesPerFile < 6) return 70;
+    if (avgEdgesPerFile < 10) return 50;
+    return 30;
+  }
+
+  private calculateCoupling(edges: DependencyEdge[], totalFiles: number): number {
+    if (totalFiles === 0 || totalFiles === 1) return 50;
+
+    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 effectiveFiles = Math.max(totalFiles - 1, 1);
+    const couplingRatio = maxEdgeCount / effectiveFiles;
+
+    if (couplingRatio < 0.15) return 100;
+    if (couplingRatio < 0.25) return 85;
+    if (couplingRatio < 0.35) return 75;
+    if (couplingRatio < 0.5) return 65;
+    if (couplingRatio < 0.7) return 50;
+    if (couplingRatio < 0.85) return 35;
+    return 20;
+  }
+
+  private findNodeWithMaxEdges(edges: DependencyEdge[]): { node: string; count: number } | null {
+    const nodeEdgeCount: Record<string, number> = {};
+
+    for (const edge of edges) {
+      nodeEdgeCount[edge.from] = (nodeEdgeCount[edge.from] || 0) + 1;
+      nodeEdgeCount[edge.to] = (nodeEdgeCount[edge.to] || 0) + 1;
+    }
+
+    let maxNode: string | null = null;
+    let maxCount = 0;
+
+    for (const [node, count] of Object.entries(nodeEdgeCount)) {
+      if (count > maxCount) {
+        maxCount = count;
+        maxNode = node;
+      }
+    }
+
+    return maxNode ? { node: maxNode, count: maxCount } : null;
+  }
+
+  private calculateCohesion(edges: DependencyEdge[]): number {
+    if (edges.length === 0) return 50;
+
+    const internalEdges = edges.filter((e) =>
+      this.isInternalDependency(e.from, e.to)
+    ).length;
+
+    const cohesionRatio = internalEdges / edges.length;
+
+    if (cohesionRatio > 0.8) return 100;
+    if (cohesionRatio > 0.6) return 85;
+    if (cohesionRatio > 0.45) return 75;
+    if (cohesionRatio > 0.3) return 65;
+    if (cohesionRatio > 0.15) return 50;
+    return 30;
+  }
+
+  private isInternalDependency(from: string, to: string): boolean {
+    const fromParts = from.split('/');
+    const toParts = to.split('/');
+
+    if (fromParts.length <= 1 && toParts.length <= 1) return true;
+
+    const fromTopLevel = fromParts.length > 1 ? fromParts[0] : '';
+    const toTopLevel = toParts.length > 1 ? toParts[0] : '';
+
+    return fromTopLevel === toTopLevel;
+  }
+
+  private calculateLayering(antiPatterns: AntiPattern[], totalFiles?: number): number {
+    const layeringViolations = antiPatterns.filter(
+      (p) =>
+        p.name === 'Leaky Abstraction' ||
+        p.name === 'Shotgun Surgery' ||
+        p.name === 'Circular Dependency'
+    ).length;
+
+    if (layeringViolations === 0) return 100;
+
+    const fileCount = Math.max(totalFiles || 50, 10);
+    const violationRatio = layeringViolations / fileCount;
+
+    if (violationRatio < 0.05) return 95;
+    if (violationRatio < 0.15) return 85;
+    if (violationRatio < 0.25) return 70;
+    if (violationRatio < 0.40) return 50;
+    if (violationRatio < 0.60) return 35;
+    return 20;
+  }
+}