vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/circular-dependency-resolver-original.js

@@ -0,0 +1,809 @@
+/**
+ * Circular Dependency Resolver
+ * 
+ * Detects and resolves circular dependencies in the codebase.
+ * Provides strategies for breaking cycles while maintaining functionality.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Dependency types
+ */
+const DEPENDENCY_TYPES = {
+  IMPORT: 'import',
+  REQUIRE: 'require',
+  DYNAMIC: 'dynamic',
+  INDIRECT: 'indirect'
+};
+
+/**
+ * Cycle severity levels
+ */
+const CYCLE_SEVERITY = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  CRITICAL: 'critical'
+};
+
+/**
+ * Dependency node class
+ */
+class DependencyNode {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.dependencies = new Set();
+    this.dependents = new Set();
+    this.visited = false;
+    this.visiting = false;
+    this.metadata = {
+      size: 0,
+      type: this.detectFileType(),
+      package: this.extractPackage()
+    };
+  }
+
+  detectFileType() {
+    const ext = path.extname(this.filePath).toLowerCase();
+    if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) return 'javascript';
+    if (ext === '.json') return 'json';
+    return 'other';
+  }
+
+  extractPackage() {
+    const match = this.filePath.match(/packages\/([^\/]+)/);
+    return match ? match[1] : 'root';
+  }
+
+  addDependency(filePath, type = DEPENDENCY_TYPES.IMPORT) {
+    this.dependencies.add({ path: filePath, type });
+  }
+
+  addDependent(filePath) {
+    this.dependents.add(filePath);
+  }
+
+  hasDependency(filePath) {
+    return this.dependencies.has(filePath);
+  }
+
+  getDependencyCount() {
+    return this.dependencies.size;
+  }
+
+  getDependentCount() {
+    return this.dependents.size;
+  }
+}
+
+/**
+ * Circular dependency class
+ */
+class CircularDependency {
+  constructor(cycle) {
+    this.cycle = cycle;
+    this.length = cycle.length;
+    this.severity = this.calculateSeverity();
+    this.impact = this.calculateImpact();
+    this.resolution = null;
+    this.metadata = {
+      detectedAt: new Date().toISOString(),
+      confidence: 0.8
+    };
+  }
+
+  calculateSeverity() {
+    if (this.length === 2) return CYCLE_SEVERITY.CRITICAL;
+    if (this.length === 3) return CYCLE_SEVERITY.HIGH;
+    if (this.length <= 5) return CYCLE_SEVERITY.MEDIUM;
+    return CYCLE_SEVERITY.LOW;
+  }
+
+  calculateImpact() {
+    let impact = 0;
+    
+    // Impact based on cycle length
+    impact += (6 - Math.min(this.length, 6)) * 10;
+    
+    // Impact based on file types
+    for (const filePath of this.cycle) {
+      if (filePath.includes('packages/core')) impact += 15;
+      if (filePath.includes('packages/cli')) impact += 10;
+      if (filePath.includes('packages/electron-app')) impact += 8;
+    }
+    
+    return Math.min(100, impact);
+  }
+
+  setResolution(resolution) {
+    this.resolution = resolution;
+  }
+
+  getSummary() {
+    return {
+      cycle: this.cycle,
+      length: this.length,
+      severity: this.severity,
+      impact: this.impact,
+      resolution: this.resolution,
+      confidence: this.metadata.confidence
+    };
+  }
+}
+
+/**
+ * Resolution strategy class
+ */
+class ResolutionStrategy {
+  constructor(type, description, effort, risk) {
+    this.type = type;
+    this.description = description;
+    this.effort = effort; // 1-10 scale
+    this.risk = risk; // 1-10 scale
+    this.steps = [];
+    this.applicable = true;
+  }
+
+  addStep(step) {
+    this.steps.push(step);
+  }
+
+  setApplicable(applicable) {
+    this.applicable = applicable;
+  }
+
+  getSummary() {
+    return {
+      type: this.type,
+      description: this.description,
+      effort: this.effort,
+      risk: this.risk,
+      steps: this.steps,
+      applicable: this.applicable
+    };
+  }
+}
+
+/**
+ * Circular dependency resolver result class
+ */
+class CircularDependencyResult {
+  constructor() {
+    this.cycles = [];
+    this.strategies = [];
+    this.resolved = [];
+    this.failed = [];
+    this.metadata = {
+      analyzedAt: new Date().toISOString(),
+      totalFiles: 0,
+      totalDependencies: 0
+    };
+    this.errors = [];
+    this.warnings = [];
+  }
+
+  addCycle(cycle) {
+    this.cycles.push(cycle);
+  }
+
+  addStrategy(strategy) {
+    this.strategies.push(strategy);
+  }
+
+  addResolved(resolution) {
+    this.resolved.push(resolution);
+  }
+
+  addFailed(failure) {
+    this.failed.push(failure);
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  getSummary() {
+    return {
+      cyclesFound: this.cycles.length,
+      strategiesGenerated: this.strategies.length,
+      cyclesResolved: this.resolved.length,
+      cyclesFailed: this.failed.length,
+      totalFiles: this.metadata.totalFiles,
+      totalDependencies: this.metadata.totalDependencies,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+
+/**
+ * Circular dependency resolver class
+ */
+class CircularDependencyResolver {
+  constructor(options = {}) {
+    this.options = {
+      maxDepth: 10,
+      includeIndirect: true,
+      ignoreTestFiles: true,
+      ignoreVendorFiles: true,
+      generateStrategies: true,
+      autoResolve: false,
+      ...options
+    };
+    
+    this.nodes = new Map();
+    this.result = new CircularDependencyResult();
+  }
+
+  /**
+   * Analyze codebase for circular dependencies
+   */
+  async analyze(rootPath = process.cwd()) {
+    console.log('Analyzing circular dependencies...');
+    
+    try {
+      // Build dependency graph
+      await this.buildDependencyGraph(rootPath);
+      
+      // Detect cycles
+      await this.detectCycles();
+      
+      // Generate resolution strategies
+      if (this.options.generateStrategies) {
+        await this.generateStrategies();
+      }
+      
+      // Auto-resolve if enabled
+      if (this.options.autoResolve) {
+        await this.autoResolve();
+      }
+      
+      this.result.metadata.totalFiles = this.nodes.size;
+      this.result.metadata.totalDependencies = this.calculateTotalDependencies();
+      
+      console.log(`Analysis complete: ${this.result.cycles.length} cycles found`);
+      
+    } catch (error) {
+      this.result.addError(error);
+    }
+    
+    return this.result;
+  }
+
+  /**
+   * Build dependency graph
+   */
+  async buildDependencyGraph(rootPath) {
+    const files = await this.getAllFiles(rootPath);
+    
+    for (const filePath of files) {
+      const node = new DependencyNode(filePath);
+      
+      // Extract dependencies from file
+      const dependencies = await this.extractDependencies(filePath);
+      for (const dep of dependencies) {
+        node.addDependency(dep.path, dep.type);
+        
+        // Add reverse dependency
+        const depNode = this.getOrCreateNode(dep.path);
+        depNode.addDependent(filePath);
+      }
+      
+      this.nodes.set(filePath, node);
+    }
+  }
+
+  /**
+   * Get all files to analyze
+   */
+  async getAllFiles(rootPath) {
+    const files = [];
+    
+    const walkDir = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory()) {
+          // Skip certain directories
+          if (this.shouldSkipDirectory(fullPath)) {
+            continue;
+          }
+          walkDir(fullPath);
+        } else if (entry.isFile()) {
+          // Only include certain file types
+          if (this.shouldIncludeFile(fullPath)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    };
+    
+    walkDir(rootPath);
+    return files;
+  }
+
+  /**
+   * Check if directory should be skipped
+   */
+  shouldSkipDirectory(dirPath) {
+    const dirName = path.basename(dirPath);
+    const skipDirs = [
+      'node_modules', '.git', 'dist', 'build', 'coverage',
+      '.vscode', '.idea', '.cursor', '.windsurf'
+    ];
+    
+    return skipDirs.includes(dirName) || dirName.startsWith('.');
+  }
+
+  /**
+   * Check if file should be included
+   */
+  shouldIncludeFile(filePath) {
+    const ext = path.extname(filePath);
+    const includeExts = ['.js', '.jsx', '.ts', '.tsx'];
+    
+    if (!includeExts.includes(ext)) {
+      return false;
+    }
+    
+    if (this.options.ignoreTestFiles && filePath.includes('test')) {
+      return false;
+    }
+    
+    if (this.options.ignoreVendorFiles && filePath.includes('vendor')) {
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Extract dependencies from file
+   */
+  async extractDependencies(filePath) {
+    const dependencies = [];
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      for (const line of lines) {
+        const trimmed = line.trim();
+        
+        // ES6 imports
+        const importMatch = trimmed.match(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/);
+        if (importMatch) {
+          const depPath = this.resolveDependencyPath(filePath, importMatch[1]);
+          if (depPath) {
+            dependencies.push({ path: depPath, type: DEPENDENCY_TYPES.IMPORT });
+          }
+        }
+        
+        // CommonJS requires
+        const requireMatch = trimmed.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+        if (requireMatch) {
+          const depPath = this.resolveDependencyPath(filePath, requireMatch[1]);
+          if (depPath) {
+            dependencies.push({ path: depPath, type: DEPENDENCY_TYPES.REQUIRE });
+          }
+        }
+        
+        // Dynamic imports
+        const dynamicMatch = trimmed.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+        if (dynamicMatch) {
+          const depPath = this.resolveDependencyPath(filePath, dynamicMatch[1]);
+          if (depPath) {
+            dependencies.push({ path: depPath, type: DEPENDENCY_TYPES.DYNAMIC });
+          }
+        }
+      }
+      
+    } catch (error) {
+      // Skip files that can't be read
+    }
+    
+    return dependencies;
+  }
+
+  /**
+   * Resolve dependency path to absolute path
+   */
+  resolveDependencyPath(fromPath, importPath) {
+    if (!importPath.startsWith('./') && !importPath.startsWith('../')) {
+      // Skip non-relative imports (node_modules, etc.)
+      return null;
+    }
+    
+    const absolutePath = path.resolve(path.dirname(fromPath), importPath);
+    
+    // Try different extensions
+    const extensions = ['.js', '.jsx', '.ts', '.tsx', '/index.js', '/index.jsx', '/index.ts', '/index.tsx'];
+    
+    for (const ext of extensions) {
+      const testPath = absolutePath + ext;
+      if (fs.existsSync(testPath)) {
+        return path.resolve(testPath);
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Detect cycles using DFS
+   */
+  async detectCycles() {
+    const visited = new Set();
+    
+    for (const [filePath, node] of this.nodes) {
+      if (!visited.has(filePath)) {
+        const cycle = this.findCycle(filePath, new Set(), new Set());
+        if (cycle.length > 0) {
+          const circularDep = new CircularDependency(cycle);
+          this.result.addCycle(circularDep);
+        }
+      }
+    }
+  }
+
+  /**
+   * Find cycle starting from a node
+   */
+  findCycle(startPath, currentPath, visiting) {
+    const node = this.nodes.get(startPath);
+    if (!node) return [];
+    
+    visiting.add(startPath);
+    
+    for (const dep of node.dependencies) {
+      const depPath = typeof dep === 'object' ? dep.path : dep;
+      
+      if (depPath === startPath) {
+        // Found cycle
+        return [startPath];
+      }
+      
+      if (visiting.has(depPath)) {
+        // Found cycle through current path
+        return [depPath, startPath];
+      }
+      
+      if (!currentPath.has(depPath)) {
+        const cycle = this.findCycle(depPath, currentPath, visiting);
+        if (cycle.length > 0) {
+          if (cycle[cycle.length - 1] === startPath) {
+            return cycle;
+          } else {
+            return [...cycle, startPath];
+          }
+        }
+      }
+    }
+    
+    visiting.delete(startPath);
+    currentPath.add(startPath);
+    
+    return [];
+  }
+
+  /**
+   * Generate resolution strategies
+   */
+  async generateStrategies() {
+    for (const cycle of this.result.cycles) {
+      const strategies = this.generateStrategiesForCycle(cycle);
+      for (const strategy of strategies) {
+        this.result.addStrategy(strategy);
+      }
+    }
+  }
+
+  /**
+   * Generate strategies for a specific cycle
+   */
+  generateStrategiesForCycle(cycle) {
+    const strategies = [];
+    
+    // Strategy 1: Extract common dependencies
+    const extractStrategy = this.generateExtractStrategy(cycle);
+    strategies.push(extractStrategy);
+    
+    // Strategy 2: Invert dependency
+    const invertStrategy = this.generateInvertStrategy(cycle);
+    strategies.push(invertStrategy);
+    
+    // Strategy 3: Introduce interface/abstraction
+    const interfaceStrategy = this.generateInterfaceStrategy(cycle);
+    strategies.push(interfaceStrategy);
+    
+    // Strategy 4: Merge modules
+    const mergeStrategy = this.generateMergeStrategy(cycle);
+    strategies.push(mergeStrategy);
+    
+    // Strategy 5: Dependency injection
+    const diStrategy = this.generateDIStrategy(cycle);
+    strategies.push(diStrategy);
+    
+    return strategies.filter(s => s.applicable);
+  }
+
+  /**
+   * Generate extract common dependencies strategy
+   */
+  generateExtractStrategy(cycle) {
+    const strategy = new ResolutionStrategy(
+      'extract_common',
+      'Extract common dependencies into a shared module',
+      6,
+      4
+    );
+    
+    strategy.addStep('Analyze all files in the cycle for common dependencies');
+    strategy.addStep('Create a new module for shared dependencies');
+    strategy.addStep('Update all files to import from the shared module');
+    strategy.addStep('Remove duplicate dependencies from individual files');
+    
+    // Check if applicable
+    const commonDeps = this.findCommonDependencies(cycle);
+    strategy.setApplicable(commonDeps.length > 1);
+    
+    return strategy;
+  }
+
+  /**
+   * Generate invert dependency strategy
+   */
+  generateInvertStrategy(cycle) {
+    const strategy = new ResolutionStrategy(
+      'invert_dependency',
+      'Invert one dependency in the cycle',
+      4,
+      3
+    );
+    
+    strategy.addStep('Identify the dependency to invert');
+    strategy.addStep('Use dependency injection or events instead');
+    strategy.addStep('Update the dependent file');
+    strategy.addStep('Test the inverted dependency');
+    
+    // Always applicable for cycles of length 2
+    strategy.setApplicable(cycle.length <= 3);
+    
+    return strategy;
+  }
+
+  /**
+   * Generate interface/abstraction strategy
+   */
+  generateInterfaceStrategy(cycle) {
+    const strategy = new ResolutionStrategy(
+      'interface_abstraction',
+      'Introduce interface/abstraction to break cycle',
+      7,
+      5
+    );
+    
+    strategy.addStep('Design an interface for the shared functionality');
+    strategy.addStep('Create the interface module');
+    strategy.addStep('Implement the interface in one of the modules');
+    strategy.addStep('Update other modules to use the interface');
+    strategy.addStep('Remove direct dependencies');
+    
+    // Check if applicable (needs TypeScript or similar)
+    strategy.setApplicable(this.hasTypeScriptFiles(cycle));
+    
+    return strategy;
+  }
+
+  /**
+   * Generate merge modules strategy
+   */
+  generateMergeStrategy(cycle) {
+    const strategy = new ResolutionStrategy(
+      'merge_modules',
+      'Merge modules in the cycle',
+      3,
+      2
+    );
+    
+    strategy.addStep('Identify modules that can be safely merged');
+    strategy.addStep('Create merged module');
+    strategy.addStep('Update all dependencies');
+    strategy.addStep('Remove original modules');
+    
+    // Check if applicable (small files only)
+    strategy.setApplicable(this.canMergeModules(cycle));
+    
+    return strategy;
+  }
+
+  /**
+   * Generate dependency injection strategy
+   */
+  generateDIStrategy(cycle) {
+    const strategy = new ResolutionStrategy(
+      'dependency_injection',
+      'Use dependency injection to break cycle',
+      8,
+      6
+    );
+    
+    strategy.addStep('Create a dependency injection container');
+    strategy.addStep('Register dependencies in the container');
+    strategy.addStep('Update modules to use injected dependencies');
+    strategy.addStep('Configure the injection at application startup');
+    
+    // Always applicable
+    strategy.setApplicable(true);
+    
+    return strategy;
+  }
+
+  /**
+   * Find common dependencies in a cycle
+   */
+  findCommonDependencies(cycle) {
+    const dependencyCounts = new Map();
+    
+    for (const filePath of cycle) {
+      const node = this.nodes.get(filePath);
+      if (node) {
+        for (const dep of node.dependencies) {
+          const depPath = typeof dep === 'object' ? dep.path : dep;
+          dependencyCounts.set(depPath, (dependencyCounts.get(depPath) || 0) + 1);
+        }
+      }
+    }
+    
+    return Array.from(dependencyCounts.entries())
+      .filter(([_, count]) => count > 1)
+      .map(([path, _]) => path);
+  }
+
+  /**
+   * Check if cycle has TypeScript files
+   */
+  hasTypeScriptFiles(cycle) {
+    return cycle.some(filePath => filePath.endsWith('.ts') || filePath.endsWith('.tsx'));
+  }
+
+  /**
+   * Check if modules can be merged
+   */
+  canMergeModules(cycle) {
+    for (const filePath of cycle) {
+      const node = this.nodes.get(filePath);
+      if (node && node.metadata.size > 200) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Auto-resolve cycles
+   */
+  async autoResolve() {
+    for (const cycle of this.result.cycles) {
+      if (cycle.severity === CYCLE_SEVERITY.CRITICAL) {
+        // Try to resolve critical cycles automatically
+        const strategy = this.result.strategies.find(s => s.applicable && s.effort <= 5);
+        if (strategy) {
+          try {
+            const resolution = await this.applyStrategy(cycle, strategy);
+            this.result.addResolved(resolution);
+          } catch (error) {
+            this.result.addFailed({ cycle, strategy, error: error.message });
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Apply a resolution strategy
+   */
+  async applyStrategy(cycle, strategy) {
+    // This would implement the actual resolution
+    // For now, return a placeholder resolution
+    return {
+      cycle: cycle.cycle,
+      strategy: strategy.type,
+      success: true,
+      changes: []
+    };
+  }
+
+  /**
+   * Get or create node
+   */
+  getOrCreateNode(filePath) {
+    if (!this.nodes.has(filePath)) {
+      this.nodes.set(filePath, new DependencyNode(filePath));
+    }
+    return this.nodes.get(filePath);
+  }
+
+  /**
+   * Calculate total dependencies
+   */
+  calculateTotalDependencies() {
+    let total = 0;
+    for (const node of this.nodes.values()) {
+      total += node.getDependencyCount();
+    }
+    return total;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStatistics() {
+    const cyclesBySeverity = {
+      [CYCLE_SEVERITY.CRITICAL]: 0,
+      [CYCLE_SEVERITY.HIGH]: 0,
+      [CYCLE_SEVERITY.MEDIUM]: 0,
+      [CYCLE_SEVERITY.LOW]: 0
+    };
+    
+    for (const cycle of this.result.cycles) {
+      cyclesBySeverity[cycle.severity]++;
+    }
+    
+    return {
+      totalFiles: this.result.metadata.totalFiles,
+      totalDependencies: this.result.metadata.totalDependencies,
+      cyclesFound: this.result.cycles.length,
+      cyclesBySeverity,
+      strategiesGenerated: this.result.strategies.length,
+      cyclesResolved: this.result.resolved.length,
+      cyclesFailed: this.result.failed.length
+    };
+  }
+
+  /**
+   * Export dependency graph
+   */
+  exportGraph(format = 'json') {
+    const graph = {
+      nodes: Array.from(this.nodes.entries()).map(([path, node]) => ({
+        path,
+        dependencies: Array.from(node.dependencies),
+        dependents: Array.from(node.dependents),
+        metadata: node.metadata
+      })),
+      cycles: this.result.cycles.map(cycle => cycle.getSummary()),
+      strategies: this.result.strategies.map(strategy => strategy.getSummary())
+    };
+    
+    if (format === 'json') {
+      return JSON.stringify(graph, null, 2);
+    }
+    
+    return graph;
+  }
+}
+
+module.exports = {
+  CircularDependencyResolver,
+  CircularDependencyResult,
+  CircularDependency,
+  DependencyNode,
+  ResolutionStrategy,
+  DEPENDENCY_TYPES,
+  CYCLE_SEVERITY
+};