vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -1,51 +1,28 @@
 /**
- * Boundary Detection Algorithms
+ * Refactored Boundary Detection Algorithms - Main Orchestrator
  */
 
-const { BOUNDARY_TYPES, COHESION_LEVELS } = require('./boundary-types');
+const FunctionDetector = require('./detectors/function-detector');
+const ClassDetector = require('./detectors/class-detector');
+const ObjectDetector = require('./detectors/object-detector');
+const ModuleDetector = require('./detectors/module-detector');
+const UtilityDetector = require('./detectors/utility-detector');
+const ConfigDetector = require('./detectors/config-detector');
+const ConstantDetector = require('./detectors/constant-detector');
+const { COHESION_LEVELS } = require('./boundary-types');
 
 /**
- * Boundary detector class
+ * Boundary detector class - orchestrates all specialized detectors
  */
 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
-      }
-    };
+    this.functionDetector = new FunctionDetector();
+    this.classDetector = new ClassDetector();
+    this.objectDetector = new ObjectDetector();
+    this.moduleDetector = new ModuleDetector();
+    this.utilityDetector = new UtilityDetector();
+    this.configDetector = new ConfigDetector();
+    this.constantDetector = new ConstantDetector();
   }
 
   /**
@@ -59,502 +36,29 @@ class BoundaryDetector {
     const boundaries = [];
     
     // Detect function boundaries
-    boundaries.push(...this.detectFunctionBoundaries(lines, filePath));
+    boundaries.push(...this.functionDetector.detectFunctionBoundaries(lines, filePath));
     
     // Detect class boundaries
-    boundaries.push(...this.detectClassBoundaries(lines, filePath));
+    boundaries.push(...this.classDetector.detectClassBoundaries(lines, filePath));
     
     // Detect object boundaries
-    boundaries.push(...this.detectObjectBoundaries(lines, filePath));
+    boundaries.push(...this.objectDetector.detectObjectBoundaries(lines, filePath));
     
     // Detect module boundaries
-    boundaries.push(...this.detectModuleBoundaries(lines, filePath));
+    boundaries.push(...this.moduleDetector.detectModuleBoundaries(lines, filePath));
     
     // Detect utility boundaries
-    boundaries.push(...this.detectUtilityBoundaries(lines, filePath));
+    boundaries.push(...this.utilityDetector.detectUtilityBoundaries(lines, filePath));
     
     // Detect config boundaries
-    boundaries.push(...this.detectConfigBoundaries(lines, filePath));
+    boundaries.push(...this.configDetector.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);
-        }
-      }
-    }
+    boundaries.push(...this.constantDetector.detectConstantBoundaries(lines, filePath));
     
     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
@@ -565,7 +69,7 @@ class BoundaryDetector {
     let cohesionScore = 0;
     
     // Single responsibility (high cohesion)
-    if (boundary.type === BOUNDARY_TYPES.FUNCTION || boundary.type === BOUNDARY_TYPES.CLASS) {
+    if (boundary.type === 'FUNCTION' || boundary.type === 'CLASS') {
       cohesionScore += 40;
     }
     
@@ -656,86 +160,12 @@ class BoundaryDetector {
     }
     
     // Increase confidence for extractable boundaries
-    if (boundary.isExtractable()) {
+    if (this.isExtractable(boundary, boundary.lines)) {
       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;