vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

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

@@ -0,0 +1,741 @@
+/**
+ * Boundary Detection Algorithms
+ */
+
+const { BOUNDARY_TYPES, COHESION_LEVELS } = require('./boundary-types');
+
+/**
+ * Boundary detector class
+ */
+class BoundaryDetector {
+  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 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 function boundaries
+    boundaries.push(...this.detectFunctionBoundaries(lines, filePath));
+    
+    // Detect class boundaries
+    boundaries.push(...this.detectClassBoundaries(lines, filePath));
+    
+    // Detect object boundaries
+    boundaries.push(...this.detectObjectBoundaries(lines, filePath));
+    
+    // Detect module boundaries
+    boundaries.push(...this.detectModuleBoundaries(lines, filePath));
+    
+    // Detect utility boundaries
+    boundaries.push(...this.detectUtilityBoundaries(lines, filePath));
+    
+    // Detect config boundaries
+    boundaries.push(...this.detectConfigBoundaries(lines, filePath));
+    
+    // Detect constant boundaries
+    boundaries.push(...this.detectConstantBoundaries(lines, filePath));
+    
+    return boundaries;
+  }
+
+  /**
+   * Detect function boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of function boundaries
+   */
+  detectFunctionBoundaries(lines, filePath) {
+    const boundaries = [];
+    const sourceCode = lines.join('\n');
+    
+    // Find function declarations
+    const matches = [...sourceCode.matchAll(this.patterns.function.declaration)];
+    
+    for (const match of matches) {
+      const functionName = match[1] || match[2];
+      if (functionName) {
+        const boundary = this.createBoundary(
+          BOUNDARY_TYPES.FUNCTION,
+          functionName,
+          lines,
+          filePath,
+          match.index
+        );
+        
+        if (boundary) {
+          boundaries.push(boundary);
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * 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.class.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;
+  }
+
+  /**
+   * Detect object boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of object boundaries
+   */
+  detectObjectBoundaries(lines, filePath) {
+    const boundaries = [];
+    const sourceCode = lines.join('\n');
+    
+    // Find object declarations
+    const matches = [...sourceCode.matchAll(this.patterns.object.declaration)];
+    
+    for (const match of matches) {
+      const objectName = match[1];
+      if (objectName) {
+        const boundary = this.createBoundary(
+          BOUNDARY_TYPES.OBJECT,
+          objectName,
+          lines,
+          filePath,
+          match.index
+        );
+        
+        if (boundary) {
+          boundaries.push(boundary);
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * Detect module boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of module boundaries
+   */
+  detectModuleBoundaries(lines, filePath) {
+    const boundaries = [];
+    const sourceCode = lines.join('\n');
+    
+    // Find export statements
+    const matches = [...sourceCode.matchAll(this.patterns.module.export)];
+    
+    for (const match of matches) {
+      const exportNames = match[1] ? match[1].split(',').map(s => s.trim()) : [match[2]];
+      
+      for (const exportName of exportNames) {
+        if (exportName && exportName !== 'default') {
+          const boundary = this.createBoundary(
+            BOUNDARY_TYPES.MODULE,
+            exportName,
+            lines,
+            filePath,
+            match.index
+          );
+          
+          if (boundary) {
+            boundaries.push(boundary);
+          }
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * Detect utility boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of utility boundaries
+   */
+  detectUtilityBoundaries(lines, filePath) {
+    const boundaries = [];
+    
+    // Look for utility function patterns
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Helper function patterns
+      if (this.isUtilityFunction(line)) {
+        const functionName = this.extractUtilityFunctionName(line);
+        if (functionName) {
+          const boundary = this.createBoundary(
+            BOUNDARY_TYPES.UTILITY,
+            functionName,
+            lines,
+            filePath,
+            i
+          );
+          
+          if (boundary) {
+            boundaries.push(boundary);
+          }
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * Detect config boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of config boundaries
+   */
+  detectConfigBoundaries(lines, filePath) {
+    const boundaries = [];
+    
+    // Look for config object patterns
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Config object patterns
+      if (this.isConfigObject(line)) {
+        const configName = this.extractConfigObjectName(line);
+        if (configName) {
+          const boundary = this.createBoundary(
+            BOUNDARY_TYPES.CONFIG,
+            configName,
+            lines,
+            filePath,
+            i
+          );
+          
+          if (boundary) {
+            boundaries.push(boundary);
+          }
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  /**
+   * Detect constant boundaries
+   * @param {Array} lines - Source code lines
+   * @param {string} filePath - File path
+   * @returns {Array} Array of constant boundaries
+   */
+  detectConstantBoundaries(lines, filePath) {
+    const boundaries = [];
+    
+    // Look for constant patterns
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Constant patterns
+      if (this.isConstantDeclaration(line)) {
+        const constantName = this.extractConstantName(line);
+        if (constantName) {
+          const boundary = this.createBoundary(
+            BOUNDARY_TYPES.CONSTANT,
+            constantName,
+            lines,
+            filePath,
+            i
+          );
+          
+          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);
+    
+    // Analyze boundary properties
+    this.analyzeBoundary(boundary, lines, startLine, endLine);
+    
+    return boundary;
+  }
+
+  /**
+   * Find the 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 the 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 cohesion
+    const cohesion = this.calculateCohesion(boundary, boundaryLines);
+    boundary.setCohesion(cohesion);
+    
+    // Determine extractability
+    const extractable = this.isExtractable(boundary, boundaryLines);
+    boundary.setExtractable(extractable);
+    
+    // Set confidence based on analysis
+    const confidence = this.calculateConfidence(boundary);
+    boundary.setConfidence(confidence);
+  }
+
+  /**
+   * 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;
+    
+    // Nesting complexity
+    const maxNesting = this.calculateMaxNesting(sourceCode);
+    complexity += maxNesting * 2;
+    
+    // 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);
+  }
+
+  /**
+   * 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 = null;
+    
+    for (const char of sourceCode) {
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar) {
+        inString = false;
+        stringChar = null;
+      } else if (!inString) {
+        if (char === '{') {
+          currentNesting++;
+          maxNesting = Math.max(maxNesting, currentNesting);
+        } else if (char === '}') {
+          currentNesting--;
+        }
+      }
+    }
+    
+    return maxNesting;
+  }
+
+  /**
+   * 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.FUNCTION || 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;
+  }
+
+  /**
+   * Calculate cohesion level
+   * @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.type === BOUNDARY_TYPES.FUNCTION || boundary.type === BOUNDARY_TYPES.CLASS) {
+      cohesionScore += 40;
+    }
+    
+    // Limited dependencies (medium cohesion)
+    if (boundary.dependencies.length <= 3) {
+      cohesionScore += 30;
+    } else if (boundary.dependencies.length <= 5) {
+      cohesionScore += 20;
+    } else {
+      cohesionScore += 10;
+    }
+    
+    // Clear purpose (high cohesion)
+    if (this.hasClearPurpose(boundary, lines)) {
+      cohesionScore += 30;
+    }
+    
+    // Convert to cohesion level
+    if (cohesionScore >= 80) return COHESION_LEVELS.HIGH;
+    if (cohesionScore >= 60) return COHESION_LEVELS.MEDIUM;
+    if (cohesionScore >= 40) return COHESION_LEVELS.LOW;
+    return COHESION_LEVELS.NONE;
+  }
+
+  /**
+   * 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]*?\*\/|\/\/.*/.test(sourceCode);
+    
+    // Check for meaningful name
+    const hasMeaningfulName = boundary.name && 
+      boundary.name.length > 2 && 
+      !/^(temp|tmp|test|dummy|helper|util)/.test(boundary.name.toLowerCase());
+    
+    // Check for implementation
+    const hasImplementation = sourceCode.includes('{') && sourceCode.includes('}');
+    
+    return hasComments || hasMeaningfulName || hasImplementation;
+  }
+
+  /**
+   * Determine 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 have reasonable cohesion
+    if (boundary.cohesion === COHESION_LEVELS.NONE) return false;
+    
+    // Must not be too complex
+    if (boundary.complexity > 70) 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.lineCount >= 10 && boundary.lineCount <= 200) {
+      confidence += 0.2;
+    }
+    
+    // Increase confidence for high cohesion
+    if (boundary.cohesion === COHESION_LEVELS.HIGH) {
+      confidence += 0.2;
+    } else if (boundary.cohesion === COHESION_LEVELS.MEDIUM) {
+      confidence += 0.1;
+    }
+    
+    // Increase confidence for extractable boundaries
+    if (boundary.isExtractable()) {
+      confidence += 0.1;
+    }
+    
+    return Math.min(1.0, confidence);
+  }
+
+  /**
+   * Check if line is a utility function
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is utility function
+   */
+  isUtilityFunction(line) {
+    const utilityPatterns = [
+      /(?:const|let|var)\s+\w+\s*=\s*\([^)]*\)\s*=>/,
+      /function\s+(?:is|has|get|set|calculate|compute|parse|format|validate|check)/,
+      /(?:is|has|get|set|calculate|compute|parse|format|validate|check)\w+\s*\(/
+    ];
+    
+    return utilityPatterns.some(pattern => pattern.test(line));
+  }
+
+  /**
+   * Extract utility function name
+   * @param {string} line - Code line
+   * @returns {string|null} Function name
+   */
+  extractUtilityFunctionName(line) {
+    const match = line.match(/(?:const|let|var)\s+(\w+)\s*=|function\s+(\w+)/);
+    return match ? match[1] || match[2] : null;
+  }
+
+  /**
+   * Check if line is config object
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is config object
+   */
+  isConfigObject(line) {
+    const configPatterns = [
+      /(?:const|let|var)\s+\w*config\w*\s*=/,
+      /(?:const|let|var)\s+\w*Config\w*\s*=/,
+      /(?:const|let|var)\s+\w*Settings\w*\s*=/
+    ];
+    
+    return configPatterns.some(pattern => pattern.test(line));
+  }
+
+  /**
+   * Extract config object name
+   * @param {string} line - Code line
+   * @returns {string|null} Config name
+   */
+  extractConfigObjectName(line) {
+    const match = line.match(/(?:const|let|var)\s+(\w*config\w*|\w*Config\w*|\w*Settings\w*)\s*=/);
+    return match ? match[1] : null;
+  }
+
+  /**
+   * Check if line is constant declaration
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is constant declaration
+   */
+  isConstantDeclaration(line) {
+    const constantPatterns = [
+      /const\s+[A-Z_][A-Z0-9_]*\s*=/,
+      /(?:const|let|var)\s+[A-Z_][A-Z0-9_]*\s*=/
+    ];
+    
+    return constantPatterns.some(pattern => pattern.test(line));
+  }
+
+  /**
+   * Extract constant name
+   * @param {string} line - Code line
+   * @returns {string|null} Constant name
+   */
+  extractConstantName(line) {
+    const match = line.match(/(?:const|let|var)\s+([A-Z_][A-Z0-9_]*)\s*=/);
+    return match ? match[1] : null;
+  }
+}
+
+module.exports = BoundaryDetector;