@girardelli/architect 6.0.0 → 8.2.0

package/src/core/diagram.ts

@@ -1,129 +0,0 @@
-import { DependencyEdge, Layer } from './types/core.js';
-
-const LAYER_THEME: Record<string, { color: string; style: string }> = {
-  API: { color: '#FFB6C1', style: 'apiStyle' },
-  Service: { color: '#87CEEB', style: 'serviceStyle' },
-  Data: { color: '#90EE90', style: 'dataStyle' },
-  UI: { color: '#FFD700', style: 'uiStyle' },
-  Infrastructure: { color: '#D3D3D3', style: 'infraStyle' },
-};
-
-export class DiagramGenerator {
-  generateComponentDiagram(
-    edges: DependencyEdge[],
-    layers: Layer[]
-  ): string {
-    const nodes = new Set<string>();
-    edges.forEach((e) => {
-      nodes.add(e.from);
-      nodes.add(e.to);
-    });
-
-    const nodeColors: Record<string, string> = {};
-    for (const layer of layers) {
-      for (const file of layer.files) {
-        const moduleName = file.split('/').pop() || file;
-        nodeColors[moduleName] = LAYER_THEME[layer.name]?.color || '#FFFFFF';
-      }
-    }
-
-    let mermaid = 'graph TB\n';
-
-    for (const node of Array.from(nodes).slice(0, 20)) {
-      const moduleName = node.split('/').pop() || node;
-      const color = nodeColors[moduleName] || '#FFFFFF';
-      mermaid += `  ${this.sanitizeNodeName(node)}["${moduleName}"]:::${this.getStyleClass(color)}\n`;
-    }
-
-    mermaid += '\n';
-
-    for (const edge of edges.slice(0, 30)) {
-      mermaid += `  ${this.sanitizeNodeName(edge.from)} --> ${this.sanitizeNodeName(edge.to)}\n`;
-    }
-
-    return this.appendCommonClassDefs(mermaid);
-  }
-
-  generateLayerDiagram(layers: Layer[]): string {
-    let mermaid = 'graph LR\n';
-
-    const layerOrder = ['UI', 'API', 'Service', 'Data', 'Infrastructure'];
-
-    for (const layerName of layerOrder) {
-      const layer = layers.find((l) => l.name === layerName);
-      if (layer && layer.files.length > 0) {
-        const nodeId = layerName.replace(/\s+/g, '_');
-        const fileCount = layer.files.length;
-        const style = LAYER_THEME[layerName]?.style || 'defaultStyle';
-        mermaid += `  ${nodeId}["${layerName}<br/>(${fileCount} files)"]:::${style}\n`;
-      }
-    }
-
-    for (let i = 0; i < layerOrder.length - 1; i++) {
-      const from = layerOrder[i].replace(/\s+/g, '_');
-      const to = layerOrder[i + 1].replace(/\s+/g, '_');
-      mermaid += `  ${from} --> ${to}\n`;
-    }
-
-    return this.appendCommonClassDefs(mermaid);
-  }
-
-  generateDependencyFlowDiagram(edges: DependencyEdge[]): string {
-    const flowMap: Record<string, number> = {};
-
-    for (const edge of edges) {
-      const flowKey = `${edge.from} -> ${edge.to}`;
-      flowMap[flowKey] = (flowMap[flowKey] || 0) + edge.weight;
-    }
-
-    const topFlows = Object.entries(flowMap)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 15);
-
-    let mermaid = 'graph LR\n';
-
-    const nodes = new Set<string>();
-    for (const [flow] of topFlows) {
-      const [from, _, to] = flow.split(' ');
-      nodes.add(from);
-      nodes.add(to);
-    }
-
-    for (const node of nodes) {
-      const moduleName = node.split('/').pop() || node;
-      mermaid += `  ${this.sanitizeNodeName(node)}["${moduleName}"]\n`;
-    }
-
-    mermaid += '\n';
-
-    for (const [flow, weight] of topFlows) {
-      const [from, _, to] = flow.split(' ');
-      const label = weight > 1 ? ` | ${weight}` : '';
-      mermaid += `  ${this.sanitizeNodeName(from)} -->|${label}| ${this.sanitizeNodeName(to)}\n`;
-    }
-
-    return mermaid; // specific diagram that doesn't use standard classDefs
-  }
-
-  private sanitizeNodeName(path: string): string {
-    return path
-      .replace(/[^a-zA-Z0-9]/g, '_')
-      .replace(/_+/g, '_')
-      .toLowerCase();
-  }
-
-  private getStyleClass(color: string): string {
-    const match = Object.values(LAYER_THEME).find(t => t.color === color);
-    return match ? match.style : 'defaultStyle';
-  }
-
-  private appendCommonClassDefs(mermaid: string): string {
-    let result = mermaid + '\n';
-    result += '  classDef apiStyle fill:#FFB6C1,stroke:#333,color:#000\n';
-    result += '  classDef serviceStyle fill:#87CEEB,stroke:#333,color:#000\n';
-    result += '  classDef dataStyle fill:#90EE90,stroke:#333,color:#000\n';
-    result += '  classDef uiStyle fill:#FFD700,stroke:#333,color:#000\n';
-    result += '  classDef infraStyle fill:#D3D3D3,stroke:#333,color:#000\n';
-    return result;
-  }
-}

package/src/core/project-summarizer.ts

@@ -1,42 +0,0 @@
-import { AnalysisReport } from './types/core.js';
-import { ProjectSummary } from './types/summarizer.js';
-
-import { PackageReader } from './summarizer/package-reader.js';
-import { ReadmeReader } from './summarizer/readme-reader.js';
-import { KeywordExtractor } from './summarizer/keyword-extractor.js';
-import { PurposeInferrer } from './summarizer/purpose-inferrer.js';
-import { ModuleInferrer } from './summarizer/module-inferrer.js';
-
-/**
- * ProjectSummarizer — infers what a project does from its metadata,
- * structure, README, package.json, and file naming conventions.
- *
- * Refactored via Facade pattern in v5.0.0
- */
-export class ProjectSummarizer {
-  private packageReader = new PackageReader();
-  private readmeReader = new ReadmeReader();
-  private keywordExtractor = new KeywordExtractor();
-  private purposeInferrer = new PurposeInferrer();
-  private moduleInferrer = new ModuleInferrer();
-
-  summarize(projectPath: string, report: AnalysisReport): ProjectSummary {
-    const packageInfo = this.packageReader.readPackageJson(projectPath);
-    const readmeContent = this.readmeReader.readReadme(projectPath);
-    const modules = this.moduleInferrer.inferModules(report, projectPath);
-    const entryPoints = this.purposeInferrer.findEntryPoints(report, projectPath);
-    const keywords = this.keywordExtractor.extractKeywords(packageInfo, readmeContent, modules, report);
-    const techStack = this.purposeInferrer.buildTechStack(report, packageInfo);
-    const description = this.purposeInferrer.buildDescription(packageInfo, readmeContent, report);
-    const purpose = this.purposeInferrer.inferPurpose(keywords, modules, report);
-
-    return {
-      description,
-      purpose,
-      modules,
-      techStack,
-      entryPoints,
-      keywords,
-    };
-  }
-}

package/src/core/refactor-engine.ts

@@ -1,112 +0,0 @@
-import { readFileSync } from 'fs';
-import { basename, dirname, join, relative } from 'path';
-import { AnalysisReport } from './types/core.js';
-import { RefactoringPlan, RefactorStep, RefactorRule, FileOperation } from './types/rules.js';
-
-// ── Tier 1 Rules ──
-import { HubSplitterRule } from './rules/hub-splitter.js';
-import { BarrelOptimizerRule } from './rules/barrel-optimizer.js';
-import { ImportOrganizerRule } from './rules/import-organizer.js';
-import { ModuleGrouperRule } from './rules/module-grouper.js';
-import { DeadCodeDetectorRule } from './rules/dead-code-detector.js';
-
-/**
- * Refactoring Engine v2.0
- * Orchestrates Tier 1 (rule-based) and Tier 2 (AST) refactoring rules.
- */
-export class RefactorEngine {
-  private rules: RefactorRule[];
-
-  constructor() {
-    this.rules = [
-      // Tier 1: Rule Engine (pattern matching)
-      new HubSplitterRule(),
-      new BarrelOptimizerRule(),
-      new ImportOrganizerRule(),
-      new ModuleGrouperRule(),
-      new DeadCodeDetectorRule(),
-    ];
-  }
-
-  /**
-   * Analyze a project and generate a refactoring plan.
-   */
-  analyze(report: AnalysisReport, projectPath: string): RefactoringPlan {
-    const allSteps: RefactorStep[] = [];
-    let stepId = 1;
-
-    // Run each rule
-    for (const rule of this.rules) {
-      const steps = rule.analyze(report, projectPath);
-      for (const step of steps) {
-        step.id = stepId++;
-        allSteps.push(step);
-      }
-    }
-
-    // Sort by priority
-    const priorityOrder: Record<string, number> = {
-      CRITICAL: 0,
-      HIGH: 1,
-      MEDIUM: 2,
-      LOW: 3,
-    };
-    allSteps.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
-
-    // Re-number after sorting
-    allSteps.forEach((s, i) => (s.id = i + 1));
-
-    // Calculate total operations
-    const totalOperations = allSteps.reduce(
-      (sum, s) => sum + s.operations.length,
-      0
-    );
-
-    // Estimate score after refactoring
-    const estimatedScoreAfter = this.estimateScoreAfter(report, allSteps);
-
-    return {
-      timestamp: new Date().toISOString(),
-      projectPath,
-      currentScore: report.score,
-      estimatedScoreAfter,
-      steps: allSteps,
-      totalOperations,
-      tier1Steps: allSteps.filter((s) => s.tier === 1).length,
-      tier2Steps: allSteps.filter((s) => s.tier === 2).length,
-    };
-  }
-
-  /**
-   * Estimates the architecture score after applying all refactoring steps.
-   */
-  private estimateScoreAfter(
-    report: AnalysisReport,
-    steps: RefactorStep[]
-  ): { overall: number; breakdown: Record<string, number> } {
-    const breakdown = { ...report.score.breakdown };
-
-    for (const step of steps) {
-      for (const impact of step.scoreImpact) {
-        if (impact.metric in breakdown) {
-          // Use estimated after value, capped at 95
-          const key = impact.metric as keyof typeof breakdown;
-          breakdown[key] = Math.min(95, Math.max(breakdown[key], impact.after));
-        }
-      }
-    }
-
-    // Recalculate overall with same weights
-    const overall = Math.round(
-      breakdown.modularity * 0.4 +
-        breakdown.coupling * 0.25 +
-        breakdown.cohesion * 0.2 +
-        breakdown.layering * 0.15
-    );
-
-    return {
-      overall: Math.min(100, overall),
-      breakdown,
-    };
-  }
-}

package/src/core/rules/barrel-optimizer.ts

@@ -1,99 +0,0 @@
-import { basename, dirname } from 'path';
-import { AnalysisReport } from '../types/core.js';
-import { RefactorRule, RefactorStep, FileOperation } from '../types/rules.js';
-
-/**
- * Barrel Optimizer Rule (Tier 1)
- * Analyzes barrel files (__init__.py, index.ts) and suggests optimization.
- * Barrel files that re-export everything create unnecessary coupling.
- */
-export class BarrelOptimizerRule implements RefactorRule {
-  name = 'barrel-optimizer';
-  tier = 1 as const;
-
-  private static readonly BARREL_FILES = new Set([
-    '__init__.py', 'index.ts', 'index.js', 'index.tsx', 'index.jsx',
-  ]);
-
-  analyze(report: AnalysisReport, projectPath: string): RefactorStep[] {
-    const steps: RefactorStep[] = [];
-
-    // Find barrel files in the dependency graph
-    const barrelNodes = report.dependencyGraph.nodes.filter((n) =>
-      BarrelOptimizerRule.BARREL_FILES.has(basename(n))
-    );
-
-    for (const barrel of barrelNodes) {
-      // Count how many things this barrel re-exports (outgoing edges)
-      const outgoing = report.dependencyGraph.edges.filter(
-        (e) => e.from === barrel
-      );
-      const incoming = report.dependencyGraph.edges.filter(
-        (e) => e.to === barrel
-      );
-
-      if (outgoing.length < 3) continue;
-
-      // Check for "pass-through" pattern: files import from barrel
-      // but barrel just re-exports from siblings
-      const siblingDir = dirname(barrel);
-      const siblingExports = outgoing.filter(
-        (e) => dirname(e.to) === siblingDir
-      );
-
-      const operations: FileOperation[] = [];
-
-      // Suggest direct imports instead of barrel
-      for (const consumer of incoming) {
-        const consumedModules = outgoing
-          .filter((e) => {
-            // Check if consumer actually needs this module
-            return report.dependencyGraph.edges.some(
-              (edge) => edge.from === consumer.from && edge.to === e.to
-            );
-          })
-          .map((e) => e.to);
-
-        if (consumedModules.length > 0) {
-          operations.push({
-            type: 'MODIFY',
-            path: consumer.from,
-            description: `Replace barrel import from \`${basename(barrel)}\` with direct imports: ${consumedModules.map((m) => basename(m)).join(', ')}`,
-          });
-        }
-      }
-
-      // Suggest simplifying the barrel
-      if (siblingExports.length > 5) {
-        operations.push({
-          type: 'MODIFY',
-          path: barrel,
-          description: `Simplify ${basename(barrel)}: only re-export public API (${siblingExports.length} re-exports detected, consider reducing)`,
-        });
-      }
-
-      if (operations.length > 0) {
-        steps.push({
-          id: 0,
-          tier: 1,
-          rule: this.name,
-          priority: outgoing.length >= 8 ? 'HIGH' : 'MEDIUM',
-          title: `Optimize barrel: ${barrel}`,
-          description: `\`${barrel}\` re-exports ${outgoing.length} modules. ` +
-            `This creates a "Shotgun Surgery" risk — any change propagates widely.`,
-          rationale: `Barrel files that re-export everything make it hard to tree-shake unused code ` +
-            `and create implicit dependencies. Direct imports make dependency relationships explicit ` +
-            `and reduce the blast radius of changes.`,
-          operations,
-          scoreImpact: [
-            { metric: 'coupling', before: report.score.breakdown.coupling, after: Math.min(95, report.score.breakdown.coupling + 10) },
-            { metric: 'layering', before: report.score.breakdown.layering, after: Math.min(95, report.score.breakdown.layering + 5) },
-          ],
-          aiPrompt: `Analyze the barrel file \`${barrel}\` which re-exports ${outgoing.length} modules. This is creating a "Shotgun Surgery" risk.\nPlease optimize it by:\n1. Removing wildcard exports (e.g., \`export *\`) if any.\n2. Only re-exporting the public API interfaces/classes meant for consumers outside this module.\n3. Updating consumers (${incoming.map(i => basename(i.from)).join(', ')}) to import from the specific files directly instead of passing through this barrel file where appropriate.`,
-        });
-      }
-    }
-
-    return steps;
-  }
-}

package/src/core/rules/dead-code-detector.ts

@@ -1,134 +0,0 @@
-import { basename } from 'path';
-import { AnalysisReport } from '../types/core.js';
-import { RefactorRule, RefactorStep, FileOperation } from '../types/rules.js';
-
-/**
- * Dead Code Detector Rule (Tier 1)
- * Finds files with no incoming edges (nobody imports them)
- * and exports that are never used.
- * 
- * Handles both path-style (deepguard/report.py) and
- * dot-notation (deepguard.report) references.
- */
-export class DeadCodeDetectorRule implements RefactorRule {
-  name = 'dead-code-detector';
-  tier = 1 as const;
-
-  private static readonly ENTRY_POINTS = new Set([
-    'main.py', 'cli.py', 'app.py', 'manage.py', 'wsgi.py', 'asgi.py',
-    'main.ts', 'main.js', 'app.ts', 'app.js', 'server.ts', 'server.js',
-    'index.html', 'setup.py', 'setup.cfg', 'pyproject.toml',
-  ]);
-
-  analyze(report: AnalysisReport, projectPath: string): RefactorStep[] {
-    const steps: RefactorStep[] = [];
-    const edges = report.dependencyGraph.edges;
-
-    // Build a set of ALL referenced targets (both path and dot-notation)
-    const allTargets = new Set<string>();
-    const allSources = new Set<string>();
-    for (const edge of edges) {
-      allTargets.add(edge.to);
-      allSources.add(edge.from);
-    }
-
-    // Only consider actual files (with path separators) as candidates
-    const fileNodes = report.dependencyGraph.nodes.filter(
-      (n) => n.includes('/') || n.includes('\\')
-    );
-
-    // Build incoming edge count considering dot-notation matches
-    const incomingCount: Record<string, number> = {};
-
-    for (const file of fileNodes) {
-      incomingCount[file] = 0;
-
-      // Direct incoming edges
-      for (const edge of edges) {
-        if (edge.to === file) {
-          incomingCount[file]++;
-        }
-      }
-
-      // Check dot-notation references:
-      // deepguard/report.py might be referenced as deepguard.report or .report
-      const dotVariants = this.getDotVariants(file);
-      for (const variant of dotVariants) {
-        if (allTargets.has(variant)) {
-          incomingCount[file]++;
-        }
-      }
-    }
-
-    // Find orphan files
-    const orphans: string[] = [];
-
-    for (const [file, count] of Object.entries(incomingCount)) {
-      const fileName = basename(file);
-
-      // Skip entry points and config files
-      if (DeadCodeDetectorRule.ENTRY_POINTS.has(fileName)) continue;
-      if (fileName.startsWith('__')) continue;
-      if (fileName.startsWith('.')) continue;
-      if (fileName.endsWith('.test.ts') || fileName.endsWith('.spec.ts')) continue;
-      if (fileName.endsWith('_test.py') || fileName.endsWith('.test.py')) continue;
-
-      // Also skip if the file has outgoing edges (it's active code)
-      if (allSources.has(file)) continue;
-
-      if (count === 0) {
-        orphans.push(file);
-      }
-    }
-
-    if (orphans.length > 0) {
-      const operations: FileOperation[] = orphans.map((file) => ({
-        type: 'DELETE' as const,
-        path: file,
-        description: `\`${basename(file)}\` has no incoming dependencies — verify if still needed`,
-      }));
-
-      steps.push({
-        id: 0,
-        tier: 1,
-        rule: this.name,
-        priority: orphans.length >= 3 ? 'MEDIUM' : 'LOW',
-        title: `Review ${orphans.length} potentially unused file(s)`,
-        description: `Found ${orphans.length} file(s) with no incoming dependencies: ` +
-          `${orphans.map((f) => `\`${basename(f)}\``).join(', ')}. ` +
-          `These may be dead code or missing from the module's public API.`,
-        rationale: `Files with zero incoming edges are either entry points (already excluded), ` +
-          `or potentially dead code. Removing dead code reduces maintenance burden ` +
-          `and improves modularity scores.`,
-        operations,
-        scoreImpact: [
-          { metric: 'modularity', before: report.score.breakdown.modularity, after: Math.min(95, report.score.breakdown.modularity + 5) },
-        ],
-        aiPrompt: `Analyze the following files: ${orphans.map(f => `\`${f}\``).join(', ')}.\nThese files currently have zero incoming dependencies across the architecture, meaning they might be dead code.\nPlease review them:\n1. If they are unused, explicitly delete them to shrink the blast radius.\n2. If they are entry points that the Architect missed, add them to the ignore list or document their usage.\n3. Make sure to remove any vestigial exports or imports pointing to them from the rest of the codebase.`,
-      });
-    }
-
-    return steps;
-  }
-
-  /**
-   * Generate dot-notation variants for a file path.
-   * "deepguard/report.py" → ["deepguard.report", ".report"]
-   */
-  private getDotVariants(filePath: string): string[] {
-    const variants: string[] = [];
-    const withoutExt = filePath.replace(/\.[^.]+$/, '');
-    const dotPath = withoutExt.replace(/[/\\]/g, '.');
-
-    variants.push(dotPath);
-
-    // Relative dot-notation: .report
-    const parts = filePath.split('/');
-    if (parts.length >= 2) {
-      const lastPart = parts[parts.length - 1].replace(/\.[^.]+$/, '');
-      variants.push(`.${lastPart}`);
-    }
-
-    return variants;
-  }
-}

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

@@ -1,135 +0,0 @@
-import { basename, dirname, join } 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,
-    }));
-  }
-}