vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/circular/graph-builder.js

@@ -0,0 +1,213 @@
+/**
+ * Dependency Graph Builder
+ * 
+ * Handles building and analyzing dependency graphs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { DependencyNode } = require('./dependency-node');
+const { DEPENDENCY_TYPES, ANALYZED_EXTENSIONS, SKIP_DIRECTORIES } = require('./dependency-types');
+
+/**
+ * Dependency graph building utilities
+ */
+class DependencyGraphBuilder {
+  constructor(options = {}) {
+    this.options = options;
+    this.nodes = new Map();
+  }
+
+  /**
+   * Build dependency graph from root path
+   */
+  async buildGraph(rootPath = process.cwd()) {
+    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);
+    }
+    
+    return this.nodes;
+  }
+
+  /**
+   * 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);
+    return SKIP_DIRECTORIES.includes(dirName) || dirName.startsWith('.');
+  }
+
+  /**
+   * Check if file should be included
+   */
+  shouldIncludeFile(filePath) {
+    const ext = path.extname(filePath);
+    
+    if (!ANALYZED_EXTENSIONS.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;
+  }
+
+  /**
+   * 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 graph statistics
+   */
+  getStatistics() {
+    return {
+      totalFiles: this.nodes.size,
+      totalDependencies: this.calculateTotalDependencies(),
+      averageDependencies: this.nodes.size > 0 ? this.calculateTotalDependencies() / this.nodes.size : 0
+    };
+  }
+}
+
+module.exports = {
+  DependencyGraphBuilder
+};

package/src/refactoring/circular/resolution-strategy.js

@@ -0,0 +1,72 @@
+/**
+ * Resolution Strategy
+ * 
+ * Represents a strategy for resolving circular dependencies.
+ */
+
+/**
+ * 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
+    };
+  }
+
+  /**
+   * Get total score (effort + risk)
+   */
+  getScore() {
+    return this.effort + this.risk;
+  }
+
+  /**
+   * Check if strategy is low risk
+   */
+  isLowRisk() {
+    return this.risk <= 3;
+  }
+
+  /**
+   * Check if strategy is low effort
+   */
+  isLowEffort() {
+    return this.effort <= 5;
+  }
+
+  /**
+   * Get recommended priority
+   */
+  getPriority() {
+    if (this.isLowRisk() && this.isLowEffort()) return 'high';
+    if (this.isLowRisk() || this.isLowEffort()) return 'medium';
+    return 'low';
+  }
+}
+
+module.exports = {
+  ResolutionStrategy
+};

package/src/refactoring/circular/strategy-generator.js

@@ -0,0 +1,229 @@
+/**
+ * Strategy Generator
+ * 
+ * Generates resolution strategies for circular dependencies.
+ */
+
+const { ResolutionStrategy } = require('./resolution-strategy');
+
+/**
+ * Strategy generation utilities
+ */
+class StrategyGenerator {
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+
+  /**
+   * Generate strategies for all cycles
+   */
+  generateStrategies(cycles) {
+    const allStrategies = [];
+    
+    for (const cycle of cycles) {
+      const strategies = this.generateStrategiesForCycle(cycle);
+      allStrategies.push(...strategies);
+    }
+    
+    return allStrategies;
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Get best strategy for a cycle
+   */
+  getBestStrategy(cycle) {
+    const strategies = this.generateStrategiesForCycle(cycle);
+    if (strategies.length === 0) return null;
+    
+    // Sort by score (effort + risk)
+    strategies.sort((a, b) => a.getScore() - b.getScore());
+    
+    return strategies[0];
+  }
+}
+
+module.exports = {
+  StrategyGenerator
+};