vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,248 @@
+/**
+ * Function Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Function boundary detector
+ */
+class FunctionDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      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
+    };
+  }
+
+  /**
+   * 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.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;
+  }
+
+  /**
+   * 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.FUNCTION) {
+      // 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 = FunctionDetector;

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

@@ -0,0 +1,249 @@
+/**
+ * Module Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Module boundary detector
+ */
+class ModuleDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      export: /export\s+(?:\{([^}]+)\}|(?:default\s+)?(?:const|let|var|function|class)\s+(\w+))/g,
+      import: /import\s+(?:\{([^}]+)\}|(?:\*\s+as)?(\w+))/g
+    };
+  }
+
+  /**
+   * 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.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;
+  }
+
+  /**
+   * 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.MODULE) {
+      // 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 = ModuleDetector;