vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,247 @@
+/**
+ * Object Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Object boundary detector
+ */
+class ObjectDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      declaration: /(?:const|let|var)\s+(\w+)\s*=\s*{/g,
+      property: /(\w+)\s*:/g,
+      method: /(\w+)\s*\([^)]*\)\s*{/g
+    };
+  }
+
+  /**
+   * 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.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;
+  }
+
+  /**
+   * 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.OBJECT) {
+      // 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 = ObjectDetector;

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

@@ -0,0 +1,338 @@
+/**
+ * Type-specific Boundary Detection Logic
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Type-specific boundary detectors
+ */
+class TypeDetectors {
+  constructor(patterns) {
+    this.patterns = patterns;
+  }
+
+  /**
+   * 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 functionMatches = [...sourceCode.matchAll(this.patterns.function.declaration)];
+    
+    for (const match of functionMatches) {
+      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 classMatches = [...sourceCode.matchAll(this.patterns.class.declaration)];
+    
+    for (const match of classMatches) {
+      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 objectMatches = [...sourceCode.matchAll(this.patterns.object.declaration)];
+    
+    for (const match of objectMatches) {
+      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 exportMatches = [...sourceCode.matchAll(this.patterns.module.export)];
+    
+    for (const match of exportMatches) {
+      const exportNames = [];
+      
+      // Named exports
+      if (match[1]) {
+        exportNames.push(...match[1].split(',').map(name => name.trim()));
+      }
+      
+      // Default exports
+      if (match[2]) {
+        exportNames.push(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();
+      
+      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();
+      
+      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;
+  }
+
+  /**
+   * Check if line is 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)/,
+      /\w+(?:is|has|get|set|calculate|compute|parse|format|validate|check)\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 = { TypeDetectors };