vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,270 @@
+/**
+ * Config Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Config boundary detector
+ */
+class ConfigDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      config: [
+        /(?:const|let|var)\s+\w*config\w*\s*=/,
+        /(?:const|let|var)\s+\w*Config\w*\s*=/,
+        /(?:const|let|var)\s+\w*Settings\w*\s*=/
+      ]
+    };
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Check if line is config object
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is config object
+   */
+  isConfigObject(line) {
+    return this.patterns.config.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;
+  }
+
+  /**
+   * 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.CONFIG) {
+      // 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 = ConfigDetector;

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

@@ -0,0 +1,269 @@
+/**
+ * Constant Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Constant boundary detector
+ */
+class ConstantDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      constant: [
+        /const\s+[A-Z_][A-Z0-9_]*\s*=/,
+        /(?:const|let|var)\s+[A-Z_][A-Z0-9_]*/
+      ]
+    };
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Check if line is constant declaration
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is constant declaration
+   */
+  isConstantDeclaration(line) {
+    return this.patterns.constant.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;
+  }
+
+  /**
+   * 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.CONSTANT) {
+      // 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 = ConstantDetector;