vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/refactoring/boundary-types.js

@@ -0,0 +1,46 @@
+/**
+ * Boundary Types and Constants
+ * 
+ * Defines constants and enums for boundary extraction.
+ */
+
+/**
+ * Boundary types
+ */
+const BOUNDARY_TYPES = {
+  FUNCTION: 'function',
+  CLASS: 'class',
+  OBJECT: 'object',
+  MODULE: 'module',
+  UTILITY: 'utility',
+  CONFIG: 'config',
+  CONSTANT: 'constant'
+};
+
+/**
+ * Cohesion levels
+ */
+const COHESION_LEVELS = {
+  HIGH: 'high',
+  MEDIUM: 'medium',
+  LOW: 'low',
+  NONE: 'none'
+};
+
+/**
+ * Default extraction options
+ */
+const DEFAULT_OPTIONS = {
+  minBoundarySize: 5,
+  maxBoundarySize: 300,
+  minCohesionScore: 0.6,
+  minConfidence: 0.7,
+  analyzeDependencies: true,
+  analyzeReferences: true
+};
+
+module.exports = {
+  BOUNDARY_TYPES,
+  COHESION_LEVELS,
+  DEFAULT_OPTIONS
+};

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

@@ -0,0 +1,88 @@
+/**
+ * Circular Dependency
+ * 
+ * Represents a detected circular dependency cycle.
+ */
+
+const { CYCLE_SEVERITY } = require('./dependency-types');
+
+/**
+ * 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,
+      detectedAt: this.metadata.detectedAt
+    };
+  }
+
+  /**
+   * Check if cycle is critical
+   */
+  isCritical() {
+    return this.severity === CYCLE_SEVERITY.CRITICAL;
+  }
+
+  /**
+   * Get files in core package
+   */
+  getCoreFiles() {
+    return this.cycle.filter(filePath => filePath.includes('packages/core'));
+  }
+
+  /**
+   * Get cycle complexity score
+   */
+  getComplexityScore() {
+    return this.impact * (this.severity === CYCLE_SEVERITY.CRITICAL ? 1.5 : 1);
+  }
+}
+
+module.exports = {
+  CircularDependency
+};

package/src/refactoring/circular/cycle-detection.js

@@ -0,0 +1,147 @@
+/**
+ * Cycle Detection
+ * 
+ * Handles detection of circular dependencies in the graph.
+ */
+
+const { CircularDependency } = require('./circular-dependency');
+
+/**
+ * Cycle detection utilities
+ */
+class CycleDetection {
+  constructor(nodes) {
+    this.nodes = nodes;
+  }
+
+  /**
+   * Detect all cycles using DFS
+   */
+  detectCycles() {
+    const cycles = [];
+    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);
+          cycles.push(circularDep);
+        }
+      }
+    }
+    
+    return cycles;
+  }
+
+  /**
+   * 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 [];
+  }
+
+  /**
+   * Find cycles by severity
+   */
+  findCyclesBySeverity(severity) {
+    const allCycles = this.detectCycles();
+    return allCycles.filter(cycle => cycle.severity === severity);
+  }
+
+  /**
+   * Find critical cycles
+   */
+  findCriticalCycles() {
+    return this.findCyclesBySeverity('critical');
+  }
+
+  /**
+   * Get cycle statistics
+   */
+  getCycleStatistics(cycles) {
+    const stats = {
+      total: cycles.length,
+      byLength: {},
+      bySeverity: {},
+      averageLength: 0,
+      totalImpact: 0
+    };
+
+    for (const cycle of cycles) {
+      // By length
+      const lengthKey = cycle.length.toString();
+      stats.byLength[lengthKey] = (stats.byLength[lengthKey] || 0) + 1;
+
+      // By severity
+      const severityKey = cycle.severity;
+      stats.bySeverity[severityKey] = (stats.bySeverity[severityKey] || 0) + 1;
+
+      stats.totalImpact += cycle.impact;
+    }
+
+    if (cycles.length > 0) {
+      stats.averageLength = cycles.reduce((sum, cycle) => sum + cycle.length, 0) / cycles.length;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Check if path is part of any cycle
+   */
+  isPathInCycle(filePath) {
+    for (const [path, node] of this.nodes) {
+      if (path === filePath) {
+        const cycle = this.findCycle(filePath, new Set(), new Set());
+        return cycle.length > 0;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Get all cycles involving a specific file
+   */
+  getCyclesForFile(filePath) {
+    const allCycles = this.detectCycles();
+    return allCycles.filter(cycle => cycle.includes(filePath));
+  }
+}
+
+module.exports = {
+  CycleDetection
+};

package/src/refactoring/circular/dependency-node.js

@@ -0,0 +1,82 @@
+/**
+ * Dependency Node
+ * 
+ * Represents a file node in the dependency graph.
+ */
+
+const path = require('path');
+const { DEPENDENCY_TYPES } = require('./dependency-types');
+
+/**
+ * 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;
+  }
+
+  /**
+   * Get node summary
+   */
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      dependencyCount: this.getDependencyCount(),
+      dependentCount: this.getDependentCount(),
+      metadata: this.metadata
+    };
+  }
+
+  /**
+   * Reset visitation state
+   */
+  resetVisitation() {
+    this.visited = false;
+    this.visiting = false;
+  }
+}
+
+module.exports = {
+  DependencyNode
+};

package/src/refactoring/circular/dependency-result.js

@@ -0,0 +1,107 @@
+/**
+ * Circular Dependency Result
+ * 
+ * Container for analysis results and metadata.
+ */
+
+/**
+ * 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
+    };
+  }
+
+  /**
+   * Get critical cycles
+   */
+  getCriticalCycles() {
+    return this.cycles.filter(cycle => cycle.isCritical());
+  }
+
+  /**
+   * Get success rate
+   */
+  getSuccessRate() {
+    const total = this.resolved.length + this.failed.length;
+    return total > 0 ? (this.resolved.length / total * 100).toFixed(1) : 0;
+  }
+
+  /**
+   * Check if analysis has errors
+   */
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+
+  /**
+   * Check if analysis has warnings
+   */
+  hasWarnings() {
+    return this.warnings.length > 0;
+  }
+
+  /**
+   * Get analysis duration
+   */
+  getAnalysisDuration() {
+    return new Date() - new Date(this.metadata.analyzedAt);
+  }
+}
+
+module.exports = {
+  CircularDependencyResult
+};

package/src/refactoring/circular/dependency-types.js

@@ -0,0 +1,58 @@
+/**
+ * Circular Dependency Types and Constants
+ * 
+ * Defines dependency types, severity levels, and shared constants.
+ */
+
+/**
+ * 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'
+};
+
+/**
+ * File extensions to analyze
+ */
+const ANALYZED_EXTENSIONS = ['.js', '.jsx', '.ts', '.tsx'];
+
+/**
+ * Directories to skip during analysis
+ */
+const SKIP_DIRECTORIES = [
+  'node_modules', '.git', 'dist', 'build', 'coverage',
+  '.vscode', '.idea', '.cursor', '.windsurf'
+];
+
+/**
+ * Default resolver options
+ */
+const DEFAULT_OPTIONS = {
+  maxDepth: 10,
+  includeIndirect: true,
+  ignoreTestFiles: true,
+  ignoreVendorFiles: true,
+  generateStrategies: true,
+  autoResolve: false
+};
+
+module.exports = {
+  DEPENDENCY_TYPES,
+  CYCLE_SEVERITY,
+  ANALYZED_EXTENSIONS,
+  SKIP_DIRECTORIES,
+  DEFAULT_OPTIONS
+};