vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/boundaries/extraction-strategies.js

@@ -0,0 +1,392 @@
+/**
+ * Extraction Strategies
+ * 
+ * Different strategies for extracting boundaries from code.
+ */
+
+const { BOUNDARY_TYPES } = require('./module-boundary');
+
+/**
+ * Base extraction strategy
+ */
+class ExtractionStrategy {
+  constructor(name) {
+    this.name = name;
+  }
+
+  /**
+   * Extract boundaries from code
+   */
+  extract(code, filePath) {
+    throw new Error('extract method must be implemented by subclass');
+  }
+
+  /**
+   * Check if strategy can handle the code
+   */
+  canHandle(code) {
+    return true;
+  }
+}
+
+/**
+ * Function extraction strategy
+ */
+class FunctionExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('function');
+  }
+
+  extract(code, filePath) {
+    const boundaries = [];
+    const lines = code.split('\n');
+    
+    // Function patterns
+    const patterns = [
+      /function\s+(\w+)\s*\([^)]*\)\s*{/g,
+      /const\s+(\w+)\s*=\s*(?:async\s+)?function\s*\([^)]*\)\s*{/g,
+      /const\s+(\w+)\s*=\s*\([^)]*\)\s*=>\s*{/g,
+      /(\w+)\s*:\s*(?:async\s+)?function\s*\([^)]*\)\s*{/g,
+      /async\s+function\s+(\w+)\s*\([^)]*\)\s*{/g
+    ];
+
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        const functionName = match[1];
+        const startIndex = match.index;
+        const startLine = this.getLineNumber(code, startIndex);
+        
+        // Find function end
+        const endIndex = this.findFunctionEnd(code, startIndex);
+        const endLine = this.getLineNumber(code, endIndex);
+        
+        if (endIndex > startIndex) {
+          const boundary = {
+            type: BOUNDARY_TYPES.FUNCTION,
+            name: functionName,
+            startLine,
+            endLine,
+            confidence: this.calculateConfidence(match[0])
+          };
+          
+          boundaries.push(boundary);
+        }
+      }
+    }
+
+    return boundaries;
+  }
+
+  findFunctionEnd(code, startIndex) {
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = '';
+    let i = startIndex;
+
+    for (; i < code.length; i++) {
+      const char = code[i];
+      
+      // Handle strings
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && code[i-1] !== '\\') {
+        inString = false;
+      }
+      
+      // Count braces when not in strings
+      if (!inString) {
+        if (char === '{') braceCount++;
+        else if (char === '}') {
+          braceCount--;
+          if (braceCount === 0) break;
+        }
+      }
+    }
+
+    return i + 1;
+  }
+
+  calculateConfidence(match) {
+    // Higher confidence for more explicit function declarations
+    if (match.startsWith('function')) return 0.9;
+    if (match.includes('function')) return 0.8;
+    if (match.includes('=>')) return 0.7;
+    return 0.6;
+  }
+
+  getLineNumber(code, index) {
+    const before = code.substring(0, index);
+    return before.split('\n').length;
+  }
+
+  canHandle(code) {
+    return /function|=>/.test(code);
+  }
+}
+
+/**
+ * Class extraction strategy
+ */
+class ClassExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('class');
+  }
+
+  extract(code, filePath) {
+    const boundaries = [];
+    const lines = code.split('\n');
+    
+    // Class patterns
+    const patterns = [
+      /class\s+(\w+)/g,
+      /class\s+(\w+)\s+extends\s+\w+/g
+    ];
+
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        const className = match[1];
+        const startIndex = match.index;
+        const startLine = this.getLineNumber(code, startIndex);
+        
+        // Find class end
+        const endIndex = this.findClassEnd(code, startIndex);
+        const endLine = this.getLineNumber(code, endIndex);
+        
+        if (endIndex > startIndex) {
+          const boundary = {
+            type: BOUNDARY_TYPES.CLASS,
+            name: className,
+            startLine,
+            endLine,
+            confidence: 0.9
+          };
+          
+          boundaries.push(boundary);
+        }
+      }
+    }
+
+    return boundaries;
+  }
+
+  findClassEnd(code, startIndex) {
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = '';
+    let i = startIndex;
+
+    for (; i < code.length; i++) {
+      const char = code[i];
+      
+      // Handle strings
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && code[i-1] !== '\\') {
+        inString = false;
+      }
+      
+      // Count braces when not in strings
+      if (!inString) {
+        if (char === '{') braceCount++;
+        else if (char === '}') {
+          braceCount--;
+          if (braceCount === 0) break;
+        }
+      }
+    }
+
+    return i + 1;
+  }
+
+  getLineNumber(code, index) {
+    const before = code.substring(0, index);
+    return before.split('\n').length;
+  }
+
+  canHandle(code) {
+    return /class/.test(code);
+  }
+}
+
+/**
+ * Object extraction strategy
+ */
+class ObjectExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('object');
+  }
+
+  extract(code, filePath) {
+    const boundaries = [];
+    const lines = code.split('\n');
+    
+    // Object patterns
+    const patterns = [
+      /(?:const|let|var)\s+(\w+)\s*=\s*\{/g,
+      /(\w+)\s*:\s*\{/g
+    ];
+
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        const objectName = match[1];
+        const startIndex = match.index;
+        const startLine = this.getLineNumber(code, startIndex);
+        
+        // Find object end
+        const endIndex = this.findObjectEnd(code, startIndex);
+        const endLine = this.getLineNumber(code, endIndex);
+        
+        if (endIndex > startIndex && endIndex - startIndex > 50) { // Only significant objects
+          const boundary = {
+            type: BOUNDARY_TYPES.OBJECT,
+            name: objectName,
+            startLine,
+            endLine,
+            confidence: 0.7
+          };
+          
+          boundaries.push(boundary);
+        }
+      }
+    }
+
+    return boundaries;
+  }
+
+  findObjectEnd(code, startIndex) {
+    let braceCount = 0;
+    let inString = false;
+    let stringChar = '';
+    let i = startIndex;
+
+    for (; i < code.length; i++) {
+      const char = code[i];
+      
+      // Handle strings
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar && code[i-1] !== '\\') {
+        inString = false;
+      }
+      
+      // Count braces when not in strings
+      if (!inString) {
+        if (char === '{') braceCount++;
+        else if (char === '}') {
+          braceCount--;
+          if (braceCount === 0) break;
+        }
+      }
+    }
+
+    return i + 1;
+  }
+
+  getLineNumber(code, index) {
+    const before = code.substring(0, index);
+    return before.split('\n').length;
+  }
+
+  canHandle(code) {
+    return /\{.*\}/.test(code);
+  }
+}
+
+/**
+ * Utility extraction strategy
+ */
+class UtilityExtractionStrategy extends ExtractionStrategy {
+  constructor() {
+    super('utility');
+  }
+
+  extract(code, filePath) {
+    const boundaries = [];
+    const lines = code.split('\n');
+    
+    // Look for utility function patterns
+    const utilityPatterns = [
+      /(?:const|let|var)\s+(is|has|can|should|get|set|parse|format|validate|calculate|compute)\w*\s*=\s*\(/g,
+      /(?:const|let|var)\s+\w*Helper\s*=\s*\(/g,
+      /(?:const|let|var)\s+\w*Utils\s*=\s*\{/g
+    ];
+
+    for (const pattern of utilityPatterns) {
+      let match;
+      while ((match = pattern.exec(code)) !== null) {
+        const utilityName = match[1] || match[0].split('=')[0].trim().split(' ').pop();
+        const startIndex = match.index;
+        const startLine = this.getLineNumber(code, startIndex);
+        
+        // Find end (simplified for utilities)
+        const endIndex = this.findUtilityEnd(code, startIndex);
+        const endLine = this.getLineNumber(code, endIndex);
+        
+        if (endIndex > startIndex) {
+          const boundary = {
+            type: BOUNDARY_TYPES.UTILITY,
+            name: utilityName,
+            startLine,
+            endLine,
+            confidence: 0.8
+          };
+          
+          boundaries.push(boundary);
+        }
+      }
+    }
+
+    return boundaries;
+  }
+
+  findUtilityEnd(code, startIndex) {
+    // Simple heuristic: find next major construct or end of file
+    const lines = code.substring(startIndex).split('\n');
+    let lineCount = 0;
+    let braceCount = 0;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      lineCount++;
+      
+      // Count braces
+      for (const char of line) {
+        if (char === '{') braceCount++;
+        else if (char === '}') braceCount--;
+      }
+      
+      // End when braces balance and we have some content
+      if (braceCount <= 0 && lineCount > 1) {
+        break;
+      }
+      
+      // Safety limit
+      if (lineCount > 50) break;
+    }
+
+    return startIndex + lines.slice(0, lineCount).join('\n').length;
+  }
+
+  getLineNumber(code, index) {
+    const before = code.substring(0, index);
+    return before.split('\n').length;
+  }
+
+  canHandle(code) {
+    return /(?:is|has|can|should|get|set|parse|format|validate|calculate|compute|Helper|Utils)/.test(code);
+  }
+}
+
+module.exports = {
+  ExtractionStrategy,
+  FunctionExtractionStrategy,
+  ClassExtractionStrategy,
+  ObjectExtractionStrategy,
+  UtilityExtractionStrategy
+};

package/src/refactoring/boundaries/module-boundary.js

@@ -0,0 +1,209 @@
+/**
+ * Module Boundary
+ * 
+ * Represents a logical boundary within code that can be extracted.
+ */
+
+const COHESION_LEVELS = {
+  HIGH: 'high',
+  MEDIUM: 'medium',
+  LOW: 'low',
+  NONE: 'none'
+};
+
+const BOUNDARY_TYPES = {
+  FUNCTION: 'function',
+  CLASS: 'class',
+  OBJECT: 'object',
+  MODULE: 'module',
+  UTILITY: 'utility',
+  CONFIG: 'config',
+  CONSTANT: 'constant'
+};
+
+/**
+ * Module boundary class
+ */
+class ModuleBoundary {
+  constructor(type, name, startLine, endLine, filePath) {
+    this.id = this.generateId();
+    this.type = type;
+    this.name = name;
+    this.startLine = startLine;
+    this.endLine = endLine;
+    this.filePath = filePath;
+    this.lineCount = endLine - startLine + 1;
+    this.cohesion = COHESION_LEVELS.NONE;
+    this.complexity = 0;
+    this.dependencies = [];
+    this.exports = [];
+    this.internalReferences = [];
+    this.metadata = {
+      extractedAt: null,
+      targetFile: null,
+      extractionStatus: 'pending'
+    };
+  }
+
+  generateId() {
+    return `boundary_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Set cohesion level
+   */
+  setCohesion(level) {
+    if (Object.values(COHESION_LEVELS).includes(level)) {
+      this.cohesion = level;
+    }
+  }
+
+  /**
+   * Set complexity score
+   */
+  setComplexity(score) {
+    this.complexity = Math.max(0, score);
+  }
+
+  /**
+   * Add dependency
+   */
+  addDependency(dependency) {
+    if (!this.dependencies.includes(dependency)) {
+      this.dependencies.push(dependency);
+    }
+  }
+
+  /**
+   * Add export
+   */
+  addExport(exportName) {
+    if (!this.exports.includes(exportName)) {
+      this.exports.push(exportName);
+    }
+  }
+
+  /**
+   * Add internal reference
+   */
+  addInternalReference(reference) {
+    if (!this.internalReferences.includes(reference)) {
+      this.internalReferences.push(reference);
+    }
+  }
+
+  /**
+   * Check if boundary is extractable
+   */
+  isExtractable() {
+    return this.lineCount >= 5 && 
+           this.cohesion !== COHESION_LEVELS.NONE &&
+           this.name.length > 0;
+  }
+
+  /**
+   * Check if boundary has high cohesion
+   */
+  hasHighCohesion() {
+    return this.cohesion === COHESION_LEVELS.HIGH;
+  }
+
+  /**
+   * Get extraction priority
+   */
+  getExtractionPriority() {
+    if (!this.isExtractable()) return 0;
+    
+    let priority = 1;
+    
+    // Larger boundaries get higher priority
+    if (this.lineCount > 50) priority += 2;
+    else if (this.lineCount > 20) priority += 1;
+    
+    // High cohesion gets higher priority
+    if (this.hasHighCohesion()) priority += 2;
+    else if (this.cohesion === COHESION_LEVELS.MEDIUM) priority += 1;
+    
+    // More dependencies increase priority (they're harder to move)
+    priority += Math.min(this.dependencies.length, 3);
+    
+    return priority;
+  }
+
+  /**
+   * Get suggested filename for extraction
+   */
+  getSuggestedFilename() {
+    const baseName = this.name.toLowerCase().replace(/[^a-z0-9]/g, '-');
+    const suffix = this.getTypeSuffix();
+    
+    return `${baseName}${suffix}.js`;
+  }
+
+  getTypeSuffix() {
+    switch (this.type) {
+      case BOUNDARY_TYPES.CLASS:
+        return '.class';
+      case BOUNDARY_TYPES.FUNCTION:
+        return '.func';
+      case BOUNDARY_TYPES.UTILITY:
+        return '.utils';
+      case BOUNDARY_TYPES.CONFIG:
+        return '.config';
+      case BOUNDARY_TYPES.CONSTANT:
+        return '.constants';
+      default:
+        return '';
+    }
+  }
+
+  /**
+   * Mark as extracted
+   */
+  markAsExtracted(targetFile) {
+    this.metadata.extractedAt = new Date().toISOString();
+    this.metadata.targetFile = targetFile;
+    this.metadata.extractionStatus = 'extracted';
+  }
+
+  /**
+   * Get boundary summary
+   */
+  getSummary() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      lineCount: this.lineCount,
+      cohesion: this.cohesion,
+      complexity: this.complexity,
+      extractable: this.isExtractable(),
+      priority: this.getExtractionPriority(),
+      suggestedFilename: this.getSuggestedFilename()
+    };
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      type: this.type,
+      name: this.name,
+      startLine: this.startLine,
+      endLine: this.endLine,
+      filePath: this.filePath,
+      lineCount: this.lineCount,
+      cohesion: this.cohesion,
+      complexity: this.complexity,
+      dependencies: this.dependencies,
+      exports: this.exports,
+      internalReferences: this.internalReferences,
+      metadata: this.metadata
+    };
+  }
+}
+
+module.exports = {
+  ModuleBoundary,
+  BOUNDARY_TYPES,
+  COHESION_LEVELS
+};