vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/boundary/detectors/boundary-analyzers.js

@@ -0,0 +1,281 @@
+/**
+ * Boundary Analysis Logic
+ */
+
+const { COHESION_LEVELS } = require('../boundary-types');
+
+/**
+ * Boundary analysis utilities
+ */
+class BoundaryAnalyzers {
+  /**
+   * Analyze a boundary and calculate metrics
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - Source code lines
+   * @param {number} startLine - Start line number
+   * @param {number} endLine - End line number
+   */
+  analyzeBoundary(boundary, lines, startLine, endLine) {
+    const boundaryLines = lines.slice(startLine, endLine + 1);
+    const sourceCode = boundaryLines.join('\n');
+    
+    // Calculate complexity metrics
+    boundary.complexity = this.calculateComplexity(sourceCode);
+    boundary.maxNesting = this.calculateMaxNesting(sourceCode);
+    
+    // Find dependencies and exports
+    boundary.dependencies = this.findDependencies(sourceCode);
+    boundary.exports = this.findExports(sourceCode, boundary.type);
+    
+    // Calculate cohesion and extractability
+    boundary.cohesion = this.calculateCohesion(boundary, boundaryLines);
+    boundary.hasClearPurpose = this.hasClearPurpose(boundary, boundaryLines);
+    boundary.isExtractable = this.isExtractable(boundary, boundaryLines);
+    
+    // Calculate confidence
+    boundary.confidence = this.calculateConfidence(boundary);
+  }
+
+  /**
+   * Calculate cyclomatic complexity
+   * @param {string} sourceCode - Source code
+   * @returns {number} Complexity score
+   */
+  calculateComplexity(sourceCode) {
+    let complexity = 0;
+    
+    // Cyclomatic complexity indicators
+    const complexityPatterns = [
+      /\bif\b/g,
+      /\belse\s+if\b/g,
+      /\bfor\b/g,
+      /\bwhile\b/g,
+      /\bdo\b/g,
+      /\bswitch\b/g,
+      /\bcase\b/g,
+      /\bcatch\b/g,
+      /\b&&\b/g,
+      /\|\|\|/g,
+      /\?/g
+    ];
+    
+    for (const pattern of complexityPatterns) {
+      const matches = sourceCode.match(pattern);
+      if (matches) {
+        complexity += matches.length;
+      }
+    }
+    
+    // Base complexity is 1
+    return complexity + 1;
+  }
+
+  /**
+   * Calculate maximum nesting level
+   * @param {string} sourceCode - Source code
+   * @returns {number} Maximum nesting level
+   */
+  calculateMaxNesting(sourceCode) {
+    let maxNesting = 0;
+    let currentNesting = 0;
+    let inString = false;
+    let stringChar = '';
+    
+    for (let i = 0; i < sourceCode.length; i++) {
+      const char = sourceCode[i];
+      
+      if (!inString) {
+        if (char === '"' || char === "'" || char === '`') {
+          inString = true;
+          stringChar = char;
+        } else if (char === '{') {
+          currentNesting++;
+          maxNesting = Math.max(maxNesting, currentNesting);
+        } else if (char === '}') {
+          currentNesting--;
+        }
+      } else {
+        if (char === stringChar) {
+          inString = false;
+          stringChar = '';
+        }
+      }
+    }
+    
+    return maxNesting;
+  }
+
+  /**
+   * Find dependencies in source code
+   * @param {string} sourceCode - Source code
+   * @returns {Array} Array of dependencies
+   */
+  findDependencies(sourceCode) {
+    const dependencies = [];
+    
+    // Import statements
+    const importMatches = sourceCode.match(/import\s+.*?from\s+['"`]([^'"`]+)['"`]/g);
+    if (importMatches) {
+      for (const importStatement of importMatches) {
+        const match = importStatement.match(/from\s+['"`]([^'"`]+)['"`]/);
+        if (match) {
+          dependencies.push(match[1]);
+        }
+      }
+    }
+    
+    // Require statements
+    const requireMatches = sourceCode.match(/require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g);
+    if (requireMatches) {
+      for (const requireStatement of requireMatches) {
+        const match = requireStatement.match(/require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/);
+        if (match) {
+          dependencies.push(match[1]);
+        }
+      }
+    }
+    
+    return [...new Set(dependencies)]; // Remove duplicates
+  }
+
+  /**
+   * Find exports in source code
+   * @param {string} sourceCode - Source code
+   * @param {string} type - Boundary type
+   * @returns {Array} Array of exports
+   */
+  findExports(sourceCode, type) {
+    const exports = [];
+    
+    if (type === 'function' || type === 'class') {
+      // Export statements
+      const exportMatches = sourceCode.match(/export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/g);
+      if (exportMatches) {
+        for (const exportStatement of exportMatches) {
+          const match = exportStatement.match(/(?:function|class|const|let|var)\s+(\w+)/);
+          if (match) {
+            exports.push(match[1]);
+          }
+        }
+      }
+    }
+    
+    return exports;
+  }
+
+  /**
+   * Calculate cohesion score
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - Boundary lines
+   * @returns {string} Cohesion level
+   */
+  calculateCohesion(boundary, lines) {
+    let cohesionScore = 0;
+    
+    // Single responsibility (high cohesion)
+    if (boundary.lineCount < 50) {
+      cohesionScore += 2;
+    }
+    
+    // Low complexity (high cohesion)
+    if (boundary.complexity < 10) {
+      cohesionScore += 2;
+    }
+    
+    // Low nesting (high cohesion)
+    if (boundary.maxNesting < 3) {
+      cohesionScore += 2;
+    }
+    
+    // Clear purpose (high cohesion)
+    if (boundary.hasClearPurpose) {
+      cohesionScore += 2;
+    }
+    
+    // Few dependencies (high cohesion)
+    if (boundary.dependencies.length < 5) {
+      cohesionScore += 2;
+    }
+    
+    // Convert score to cohesion level
+    if (cohesionScore >= 8) {
+      return COHESION_LEVELS.HIGH;
+    } else if (cohesionScore >= 5) {
+      return COHESION_LEVELS.MEDIUM;
+    } else {
+      return COHESION_LEVELS.LOW;
+    }
+  }
+
+  /**
+   * Check if boundary has clear purpose
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - Boundary lines
+   * @returns {boolean} Whether boundary has clear purpose
+   */
+  hasClearPurpose(boundary, lines) {
+    const sourceCode = lines.join('\n');
+    
+    // Check for comments explaining purpose
+    const hasComments = /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm.test(sourceCode);
+    
+    // Check for meaningful name
+    const hasMeaningfulName = boundary.name.length > 2 && 
+                             !/^(temp|tmp|test|data|item|obj)/.test(boundary.name.toLowerCase());
+    
+    // Check for single responsibility
+    const hasSingleResponsibility = boundary.complexity < 15 && boundary.lineCount < 100;
+    
+    return hasComments || (hasMeaningfulName && hasSingleResponsibility);
+  }
+
+  /**
+   * Check if boundary is extractable
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - Boundary lines
+   * @returns {boolean} Whether boundary is extractable
+   */
+  isExtractable(boundary, lines) {
+    // Must have clear boundaries
+    if (boundary.lineCount < 5) return false;
+    
+    // Must not be too complex
+    if (boundary.complexity > 20) return false;
+    
+    // Must have clear purpose
+    if (!boundary.hasClearPurpose) return false;
+    
+    // Must have reasonable dependencies
+    if (boundary.dependencies.length > 10) return false;
+    
+    return true;
+  }
+
+  /**
+   * Calculate confidence score
+   * @param {Object} boundary - Boundary object
+   * @returns {number} Confidence score (0-1)
+   */
+  calculateConfidence(boundary) {
+    let confidence = 0.5; // Base confidence
+    
+    // Increase confidence for clear boundaries
+    if (boundary.hasClearPurpose) {
+      confidence += 0.2;
+    }
+    
+    // Increase confidence for extractable boundaries
+    if (boundary.isExtractable) {
+      confidence += 0.2;
+    }
+    
+    // Increase confidence for high cohesion
+    if (boundary.cohesion === COHESION_LEVELS.HIGH) {
+      confidence += 0.1;
+    }
+    
+    return Math.min(confidence, 1.0);
+  }
+}
+
+module.exports = { BoundaryAnalyzers };

package/src/refactoring/boundary/detectors/boundary-core.js

@@ -0,0 +1,167 @@
+/**
+ * Core Boundary Detection Logic
+ */
+
+const { BOUNDARY_TYPES, COHESION_LEVELS } = require('../boundary-types');
+
+/**
+ * Core boundary detector class with main detection logic
+ */
+class BoundaryCore {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      // Function patterns
+      function: {
+        declaration: /(?:function\s+(\w+)\s*\(|const\s+(\w+)\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>))/g,
+        export: /(?:export\s+(?:default\s+)?(?:function|const|let|var)\s+(\w+))/g,
+        method: /(?:async\s+)?(\w+)\s*\([^)]*\)\s*{/g,
+        arrow: /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/g
+      },
+      
+      // Class patterns
+      class: {
+        declaration: /(?:class\s+(\w+)|export\s+(?:default\s+)?class\s+(\w+))/g,
+        method: /(?:async\s+)?(\w+)\s*\([^)]*\)\s*{/g,
+        property: /(\w+)\s*[=:]/g
+      },
+      
+      // Object patterns
+      object: {
+        declaration: /(?:const|let|var)\s+(\w+)\s*=\s*{/g,
+        property: /(\w+)\s*:/g,
+        method: /(\w+)\s*\([^)]*\)\s*{/g
+      },
+      
+      // Module patterns
+      module: {
+        export: /export\s+(?:\{([^}]+)\}|(?:default\s+)?(?:const|let|var|function|class)\s+(\w+))/g,
+        import: /import\s+(?:\{([^}]+)\}|(?:\*\s+as)?(\w+))/g
+      }
+    };
+  }
+
+  /**
+   * Detect all boundaries in source code
+   * @param {string} sourceCode - Source code to analyze
+   * @param {string} filePath - File path
+   * @returns {Array} Array of detected boundaries
+   */
+  detectBoundaries(sourceCode, filePath) {
+    const lines = sourceCode.split('\n');
+    const boundaries = [];
+    
+    // Detect different types of boundaries
+    boundaries.push(...this.detectFunctionBoundaries(lines, filePath));
+    boundaries.push(...this.detectClassBoundaries(lines, filePath));
+    boundaries.push(...this.detectObjectBoundaries(lines, filePath));
+    boundaries.push(...this.detectModuleBoundaries(lines, filePath));
+    boundaries.push(...this.detectUtilityBoundaries(lines, filePath));
+    boundaries.push(...this.detectConfigBoundaries(lines, filePath));
+    boundaries.push(...this.detectConstantBoundaries(lines, filePath));
+    
+    return boundaries;
+  }
+
+  /**
+   * Create a boundary object
+   * @param {string} type - Boundary type
+   * @param {string} name - Boundary name
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @param {number} startIndex - Start index in source
+   * @returns {Object|null} Boundary object or null
+   */
+  createBoundary(type, name, lines, filePath, startIndex) {
+    const { startLine, endLine } = this.findBoundaryExtent(lines, startIndex, type);
+    
+    if (startLine === -1 || endLine === -1) {
+      return null;
+    }
+    
+    const boundary = {
+      type,
+      name,
+      filePath,
+      startLine,
+      endLine,
+      lineCount: endLine - startLine + 1,
+      startIndex,
+      complexity: 0,
+      maxNesting: 0,
+      dependencies: [],
+      exports: [],
+      cohesion: COHESION_LEVELS.UNKNOWN,
+      hasClearPurpose: false,
+      isExtractable: false,
+      confidence: 0
+    };
+    
+    // Analyze the boundary
+    this.analyzeBoundary(boundary, lines, startLine, endLine);
+    
+    return boundary;
+  }
+
+  /**
+   * Find the extent of a boundary (start and end lines)
+   * @param {Array} lines - Source code lines
+   * @param {number} startIndex - Start index
+   * @param {string} type - Boundary type
+   * @returns {Object} Start and end line numbers
+   */
+  findBoundaryExtent(lines, startIndex, type) {
+    let startLine = -1;
+    let endLine = -1;
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = '';
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Track string boundaries
+      for (let j = 0; j < line.length; j++) {
+        const char = line[j];
+        
+        if (!inString) {
+          if (char === '"' || char === "'" || char === '`') {
+            inString = true;
+            stringChar = char;
+          } else if (char === '{') {
+            braceCount++;
+            if (startLine === -1) {
+              startLine = i;
+            }
+          } else if (char === '}') {
+            braceCount--;
+            if (braceCount === 0 && startLine !== -1) {
+              endLine = i;
+              break;
+            }
+          }
+        } else {
+          if (char === stringChar) {
+            inString = false;
+            stringChar = '';
+          }
+        }
+      }
+      
+      if (endLine !== -1) {
+        break;
+      }
+    }
+    
+    return { startLine, endLine };
+  }
+}
+
+module.exports = { BoundaryCore };

package/src/refactoring/boundary/detectors/class-detector.js

@@ -0,0 +1,247 @@
+/**
+ * Class Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Class boundary detector
+ */
+class ClassDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      declaration: /(?:class\s+(\w+)|export\s+(?:default\s+)?class\s+(\w+))/g,
+      method: /(?:async\s+)?(\w+)\s*\([^)]*\)\s*{/g,
+      property: /(\w+)\s*[=:]/g
+    };
+  }
+
+  /**
+   * Detect class boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of class boundaries
+   */
+  detectClassBoundaries(lines, filePath) {
+    const boundaries = [];
+    const sourceCode = lines.join('\n');
+    
+    // Find class declarations
+    const matches = [...sourceCode.matchAll(this.patterns.declaration)];
+    
+    for (const match of matches) {
+      const className = match[1] || match[2];
+      if (className) {
+        const boundary = this.createBoundary(
+          BOUNDARY_TYPES.CLASS,
+          className,
+          lines,
+          filePath,
+          match.index
+        );
+        
+        if (boundary) {
+          boundaries.push(boundary);
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * Create boundary from detection
+   * @param {string} type - Boundary type
+   * @param {string} name - Boundary name
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @param {number} startIndex - Start index in source
+   * @returns {Object|null} Boundary object or null
+   */
+  createBoundary(type, name, lines, filePath, startIndex) {
+    const { startLine, endLine } = this.findBoundaryExtent(lines, startIndex, type);
+    
+    if (startLine === -1 || endLine === -1) {
+      return null;
+    }
+    
+    const { ModuleBoundary } = require('../boundary-types');
+    const boundary = new ModuleBoundary(type, name, startLine + 1, endLine + 1, filePath);
+    
+    // Basic analysis
+    this.analyzeBoundary(boundary, lines, startLine, endLine);
+    
+    return boundary;
+  }
+
+  /**
+   * Find extent of a boundary
+   * @param {Array} lines - Source code lines
+   * @param {number} startIndex - Start index
+   * @param {string} type - Boundary type
+   * @returns {Object} Start and end line numbers
+   */
+  findBoundaryExtent(lines, startIndex, type) {
+    let startLine = -1;
+    let endLine = -1;
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = null;
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Track string literals
+      for (let j = 0; j < line.length; j++) {
+        const char = line[j];
+        
+        if (!inString && (char === '"' || char === "'" || char === '`')) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar) {
+          inString = false;
+          stringChar = null;
+        }
+      }
+      
+      // Skip lines inside strings
+      if (inString) continue;
+      
+      // Count braces for block detection
+      const openBraces = (line.match(/\{/g) || []).length;
+      const closeBraces = (line.match(/\}/g) || []).length;
+      
+      braceCount += openBraces - closeBraces;
+      
+      // Set start line on first detection
+      if (startLine === -1) {
+        startLine = i;
+      }
+      
+      // End when braces are balanced and we're past start
+      if (braceCount <= 0 && i > startIndex) {
+        endLine = i;
+        break;
+      }
+    }
+    
+    return { startLine, endLine };
+  }
+
+  /**
+   * Analyze boundary properties
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - Source code lines
+   * @param {number} startLine - Start line number
+   * @param {number} endLine - End line number
+   */
+  analyzeBoundary(boundary, lines, startLine, endLine) {
+    const boundaryLines = lines.slice(startLine, endLine + 1);
+    const sourceCode = boundaryLines.join('\n');
+    
+    // Calculate complexity
+    const complexity = this.calculateComplexity(sourceCode);
+    boundary.setComplexity(complexity);
+    
+    // Find dependencies
+    const dependencies = this.findDependencies(sourceCode);
+    for (const dep of dependencies) {
+      boundary.addDependency(dep);
+    }
+    
+    // Find exports
+    const exports = this.findExports(sourceCode, boundary.type);
+    for (const exp of exports) {
+      boundary.addExport(exp);
+    }
+  }
+
+  /**
+   * Calculate complexity score
+   * @param {string} sourceCode - Source code
+   * @returns {number} Complexity score
+   */
+  calculateComplexity(sourceCode) {
+    let complexity = 0;
+    
+    // Cyclomatic complexity indicators
+    complexity += (sourceCode.match(/if\s*\(/g) || []).length * 1;
+    complexity += (sourceCode.match(/else\s+if/g) || []).length * 1;
+    complexity += (sourceCode.match(/while\s*\(/g) || []).length * 2;
+    complexity += (sourceCode.match(/for\s*\(/g) || []).length * 2;
+    complexity += (sourceCode.match(/switch\s*\(/g) || []).length * 2;
+    complexity += (sourceCode.match(/catch\s*\(/g) || []).length * 2;
+    complexity += (sourceCode.match(/&&/g) || []).length * 1;
+    complexity += (sourceCode.match(/\|\|/g) || []).length * 1;
+    
+    // Length complexity
+    const lineCount = sourceCode.split('\n').length;
+    if (lineCount > 50) complexity += 5;
+    if (lineCount > 100) complexity += 10;
+    if (lineCount > 200) complexity += 20;
+    
+    return Math.min(100, complexity);
+  }
+
+  /**
+   * Find dependencies in boundary
+   * @param {string} sourceCode - Source code
+   * @returns {Array} Array of dependencies
+   */
+  findDependencies(sourceCode) {
+    const dependencies = [];
+    
+    // Import statements
+    const importMatches = sourceCode.match(/import\s+.+from\s+['"]([^'"]+)['"]/g);
+    if (importMatches) {
+      for (const match of importMatches) {
+        dependencies.push(match[1]);
+      }
+    }
+    
+    // Require statements
+    const requireMatches = sourceCode.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+    if (requireMatches) {
+      for (const match of requireMatches) {
+        dependencies.push(match[1]);
+      }
+    }
+    
+    return [...new Set(dependencies)];
+  }
+
+  /**
+   * Find exports in boundary
+   * @param {string} sourceCode - Source code
+   * @param {string} type - Boundary type
+   * @returns {Array} Array of exports
+   */
+  findExports(sourceCode, type) {
+    const exports = [];
+    
+    if (type === BOUNDARY_TYPES.CLASS) {
+      // Look for explicit exports
+      const exportMatches = sourceCode.match(/export\s+(?:default\s+)?(?:\w+|\{[^}]+\})/g);
+      if (exportMatches) {
+        for (const match of exportMatches) {
+          const exportName = match.replace(/export\s+(?:default\s+)?/, '').trim();
+          if (exportName && exportName !== '{' && exportName !== '}') {
+            exports.push(exportName);
+          }
+        }
+      }
+    }
+    
+    return exports;
+  }
+}
+
+module.exports = ClassDetector;