vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/analysis/boundary-detector.js

@@ -0,0 +1,712 @@
+/**
+ * Logical Boundary Detector
+ * 
+ * Uses AST analysis to detect logical boundaries in files for refactoring.
+ * Identifies functions, classes, modules, and other logical segments.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Boundary types
+ */
+const BOUNDARY_TYPES = {
+  FUNCTION: 'function',
+  CLASS: 'class',
+  MODULE: 'module',
+  BLOCK: 'block',
+  IMPORT: 'import',
+  EXPORT: 'export',
+  COMMENT: 'comment',
+  UTILITY: 'utility',
+  CONSTANT: 'constant'
+};
+
+/**
+ * Boundary detection result class
+ */
+class BoundaryDetectionResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.boundaries = [];
+    this.metadata = {
+      totalBoundaries: 0,
+      byType: {},
+      complexity: 'unknown',
+      cohesion: 'unknown',
+      coupling: 'unknown'
+    };
+  }
+
+  addBoundary(boundary) {
+    this.boundaries.push(boundary);
+    this.metadata.totalBoundaries++;
+    
+    if (!this.metadata.byType[boundary.type]) {
+      this.metadata.byType[boundary.type] = 0;
+    }
+    this.metadata.byType[boundary.type]++;
+  }
+
+  getBoundariesByType(type) {
+    return this.boundaries.filter(b => b.type === type);
+  }
+
+  getLargestBoundaries(count = 5) {
+    return this.boundaries
+      .sort((a, b) => b.lineCount - a.lineCount)
+      .slice(0, count);
+  }
+
+  getRefactoringCandidates() {
+    return this.boundaries.filter(b => 
+      b.lineCount > 50 && // Reasonable size
+      (b.type === BOUNDARY_TYPES.FUNCTION || b.type === BOUNDARY_TYPES.CLASS)
+    );
+  }
+}
+
+/**
+ * Boundary class
+ */
+class Boundary {
+  constructor(type, startLine, endLine, name = '') {
+    this.type = type;
+    this.startLine = startLine;
+    this.endLine = endLine;
+    this.name = name;
+    this.lineCount = endLine - startLine + 1;
+    this.complexity = 0;
+    this.dependencies = [];
+    this.exports = [];
+    this.comments = [];
+    this.metadata = {};
+  }
+
+  addDependency(dependency) {
+    this.dependencies.push(dependency);
+  }
+
+  addExport(exportName) {
+    this.exports.push(exportName);
+  }
+
+  addComment(comment) {
+    this.comments.push(comment);
+  }
+
+  setComplexity(complexity) {
+    this.complexity = complexity;
+  }
+
+  canExtract() {
+    // Basic criteria for extraction
+    return this.lineCount >= 10 && 
+           this.name !== '' && 
+           (this.type === BOUNDARY_TYPES.FUNCTION || this.type === BOUNDARY_TYPES.CLASS);
+  }
+}
+
+/**
+ * Logical boundary detector class
+ */
+class BoundaryDetector {
+  constructor(options = {}) {
+    this.options = {
+      minFunctionSize: 5,
+      minClassSize: 10,
+      detectComments: true,
+      detectUtilities: true,
+      ...options
+    };
+  }
+
+  /**
+   * Detect boundaries in a file
+   */
+  async detectBoundaries(filePath) {
+    const result = new BoundaryDetectionResult(filePath);
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Detect based on file type
+      const ext = path.extname(filePath).toLowerCase();
+      
+      if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+        await this.detectJavaScriptBoundaries(content, lines, result);
+      } else if (ext === '.md') {
+        await this.detectMarkdownBoundaries(content, lines, result);
+      } else {
+        await this.detectTextBoundaries(content, lines, result);
+      }
+
+      // Analyze overall structure
+      this.analyzeStructure(result);
+      
+    } catch (error) {
+      console.error(`Error detecting boundaries in ${filePath}: ${error.message}`);
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect boundaries in JavaScript/TypeScript files
+   */
+  async detectJavaScriptBoundaries(content, lines, result) {
+    // Detect imports
+    this.detectImports(lines, result);
+    
+    // Detect exports
+    this.detectExports(lines, result);
+    
+    // Detect functions
+    this.detectFunctions(lines, result);
+    
+    // Detect classes
+    this.detectClasses(lines, result);
+    
+    // Detect utility sections
+    if (this.options.detectUtilities) {
+      this.detectUtilities(lines, result);
+    }
+    
+    // Detect comment blocks
+    if (this.options.detectComments) {
+      this.detectCommentBlocks(lines, result);
+    }
+  }
+
+  /**
+   * Detect import statements
+   */
+  detectImports(lines, result) {
+    let currentImport = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('import ')) {
+        if (currentImport) {
+          // Close previous import
+          currentImport.endLine = i - 1;
+          currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
+          result.addBoundary(currentImport);
+        }
+        
+        // Start new import
+        const match = line.match(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/);
+        currentImport = new Boundary(
+          BOUNDARY_TYPES.IMPORT,
+          i,
+          i,
+          match ? match[1] : 'import'
+        );
+      } else if (currentImport && (line.startsWith('from ') || line.endsWith(';'))) {
+        // End of import statement
+        currentImport.endLine = i;
+        currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
+        result.addBoundary(currentImport);
+        currentImport = null;
+      }
+    }
+    
+    // Handle unclosed import
+    if (currentImport) {
+      currentImport.endLine = lines.length - 1;
+      currentImport.lineCount = currentImport.endLine - currentImport.startLine + 1;
+      result.addBoundary(currentImport);
+    }
+  }
+
+  /**
+   * Detect export statements
+   */
+  detectExports(lines, result) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('export ')) {
+        const match = line.match(/export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/);
+        const name = match ? match[1] : 'export';
+        
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.EXPORT,
+          i,
+          i,
+          name
+        );
+        
+        result.addBoundary(boundary);
+      }
+    }
+  }
+
+  /**
+   * Detect function boundaries
+   */
+  detectFunctions(lines, result) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Function declarations
+      const funcMatch = line.match(/^(?:async\s+)?function\s+(\w+)/);
+      if (funcMatch) {
+        const boundary = this.findFunctionBoundary(lines, i, funcMatch[1], 'declaration');
+        if (boundary) result.addBoundary(boundary);
+        continue;
+      }
+      
+      // Function expressions
+      const exprMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/);
+      if (exprMatch) {
+        const boundary = this.findFunctionBoundary(lines, i, exprMatch[1], 'expression');
+        if (boundary) result.addBoundary(boundary);
+        continue;
+      }
+      
+      // Arrow functions
+      const arrowMatch = line.match(/^(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+      if (arrowMatch) {
+        const boundary = this.findArrowFunctionBoundary(lines, i, arrowMatch[1]);
+        if (boundary) result.addBoundary(boundary);
+        continue;
+      }
+      
+      // Method definitions in classes
+      const methodMatch = line.match(/^(\w+)\s*\(/);
+      if (methodMatch && this.isInClass(lines, i)) {
+        const boundary = this.findMethodBoundary(lines, i, methodMatch[1]);
+        if (boundary) result.addBoundary(boundary);
+      }
+    }
+  }
+
+  /**
+   * Find function boundary
+   */
+  findFunctionBoundary(lines, startLine, name, type) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') {
+          braceCount++;
+          foundBrace = true;
+        } else if (line[j] === '}') {
+          braceCount--;
+          if (foundBrace && braceCount === 0) {
+            const boundary = new Boundary(
+              BOUNDARY_TYPES.FUNCTION,
+              startLine,
+              i,
+              name
+            );
+            boundary.metadata.type = type;
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find arrow function boundary
+   */
+  findArrowFunctionBoundary(lines, startLine, name) {
+    let braceCount = 0;
+    let foundBrace = false;
+    let foundArrow = false;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.includes('=>')) {
+        foundArrow = true;
+      }
+      
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') {
+          braceCount++;
+          foundBrace = true;
+        } else if (line[j] === '}') {
+          braceCount--;
+          if (foundBrace && foundArrow && braceCount === 0) {
+            const boundary = new Boundary(
+              BOUNDARY_TYPES.FUNCTION,
+              startLine,
+              i,
+              name
+            );
+            boundary.metadata.type = 'arrow';
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find method boundary
+   */
+  findMethodBoundary(lines, startLine, name) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') {
+          braceCount++;
+          foundBrace = true;
+        } else if (line[j] === '}') {
+          braceCount--;
+          if (foundBrace && braceCount === 0) {
+            const boundary = new Boundary(
+              BOUNDARY_TYPES.FUNCTION,
+              startLine,
+              i,
+              name
+            );
+            boundary.metadata.type = 'method';
+            return boundary;
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Detect class boundaries
+   */
+  detectClasses(lines, result) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      const classMatch = line.match(/^class\s+(\w+)/);
+      if (classMatch) {
+        const boundary = this.findClassBoundary(lines, i, classMatch[1]);
+        if (boundary) result.addBoundary(boundary);
+      }
+    }
+  }
+
+  /**
+   * Find class boundary
+   */
+  findClassBoundary(lines, startLine, name) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') {
+          braceCount++;
+          foundBrace = true;
+        } else if (line[j] === '}') {
+          braceCount--;
+          if (foundBrace && braceCount === 0) {
+            return new Boundary(
+              BOUNDARY_TYPES.CLASS,
+              startLine,
+              i,
+              name
+            );
+          }
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Detect utility sections
+   */
+  detectUtilities(lines, result) {
+    // Look for sections with utility functions
+    let utilityStart = null;
+    let utilityName = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Detect utility section comments
+      if (line.startsWith('//') && (line.includes('utility') || line.includes('helper'))) {
+        if (utilityStart) {
+          // Close previous utility section
+          const boundary = new Boundary(
+            BOUNDARY_TYPES.UTILITY,
+            utilityStart,
+            i - 1,
+            utilityName || 'utilities'
+          );
+          result.addBoundary(boundary);
+        }
+        
+        utilityStart = i;
+        utilityName = line.replace('//', '').trim();
+      }
+    }
+    
+    // Close final utility section
+    if (utilityStart) {
+      const boundary = new Boundary(
+        BOUNDARY_TYPES.UTILITY,
+        utilityStart,
+        lines.length - 1,
+        utilityName || 'utilities'
+      );
+      result.addBoundary(boundary);
+    }
+  }
+
+  /**
+   * Detect comment blocks
+   */
+  detectCommentBlocks(lines, result) {
+    let commentStart = null;
+    let commentType = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line.startsWith('/*')) {
+        commentStart = i;
+        commentType = 'block';
+      } else if (line.startsWith('//')) {
+        // Single line comment
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.COMMENT,
+          i,
+          i,
+          'single-line-comment'
+        );
+        result.addBoundary(boundary);
+      } else if (commentStart && line.endsWith('*/')) {
+        // End of block comment
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.COMMENT,
+          commentStart,
+          i,
+          'block-comment'
+        );
+        result.addBoundary(boundary);
+        commentStart = null;
+        commentType = null;
+      }
+    }
+  }
+
+  /**
+   * Detect boundaries in Markdown files
+   */
+  async detectMarkdownBoundaries(content, lines, result) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Headers
+      const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+      if (headerMatch) {
+        const level = headerMatch[1].length;
+        const title = headerMatch[2];
+        
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.MODULE,
+          i,
+          i,
+          title
+        );
+        boundary.metadata.level = level;
+        result.addBoundary(boundary);
+      }
+      
+      // Code blocks
+      if (line.startsWith('```')) {
+        const boundary = new Boundary(
+          BOUNDARY_TYPES.BLOCK,
+          i,
+          i,
+          'code-block'
+        );
+        result.addBoundary(boundary);
+      }
+    }
+  }
+
+  /**
+   * Detect boundaries in text files
+   */
+  async detectTextBoundaries(content, lines, result) {
+    // Simple paragraph detection
+    let paragraphStart = null;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      if (line !== '') {
+        if (paragraphStart === null) {
+          paragraphStart = i;
+        }
+      } else {
+        if (paragraphStart !== null) {
+          const boundary = new Boundary(
+            BOUNDARY_TYPES.BLOCK,
+            paragraphStart,
+            i - 1,
+            'paragraph'
+          );
+          result.addBoundary(boundary);
+          paragraphStart = null;
+        }
+      }
+    }
+    
+    // Handle final paragraph
+    if (paragraphStart !== null) {
+      const boundary = new Boundary(
+        BOUNDARY_TYPES.BLOCK,
+        paragraphStart,
+        lines.length - 1,
+        'paragraph'
+      );
+      result.addBoundary(boundary);
+    }
+  }
+
+  /**
+   * Check if line is inside a class
+   */
+  isInClass(lines, lineIndex) {
+    // Simple check - look backwards for class declaration
+    for (let i = lineIndex - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line.startsWith('class ')) {
+        return true;
+      }
+      if (line.startsWith('function ') || line.startsWith('const ')) {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Analyze overall structure
+   */
+  analyzeStructure(result) {
+    // Calculate complexity metrics
+    const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
+    const classes = result.getBoundariesByType(BOUNDARY_TYPES.CLASS);
+    
+    let totalComplexity = 0;
+    let totalSize = 0;
+    
+    for (const boundary of [...functions, ...classes]) {
+      // Simple complexity estimation based on size
+      boundary.complexity = Math.min(10, Math.ceil(boundary.lineCount / 20));
+      totalComplexity += boundary.complexity;
+      totalSize += boundary.lineCount;
+    }
+    
+    result.metadata.complexity = totalComplexity > 20 ? 'high' : 
+                               totalComplexity > 10 ? 'medium' : 'low';
+    
+    result.metadata.cohesion = this.assessCohesion(result);
+    result.metadata.coupling = this.assessCoupling(result);
+  }
+
+  /**
+   * Assess cohesion
+   */
+  assessCohesion(result) {
+    // Simple cohesion assessment based on boundary distribution
+    const functions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION);
+    const avgFunctionSize = functions.length > 0 ? 
+      functions.reduce((sum, f) => sum + f.lineCount, 0) / functions.length : 0;
+    
+    if (avgFunctionSize > 100) return 'low';
+    if (avgFunctionSize > 50) return 'medium';
+    return 'high';
+  }
+
+  /**
+   * Assess coupling
+   */
+  assessCoupling(result) {
+    // Simple coupling assessment based on imports
+    const imports = result.getBoundariesByType(BOUNDARY_TYPES.IMPORT);
+    
+    if (imports.length > 10) return 'high';
+    if (imports.length > 5) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Get refactoring recommendations
+   */
+  getRefactoringRecommendations(result) {
+    const recommendations = [];
+    
+    // Large functions
+    const largeFunctions = result.getBoundariesByType(BOUNDARY_TYPES.FUNCTION)
+      .filter(f => f.lineCount > 50);
+    
+    if (largeFunctions.length > 0) {
+      recommendations.push({
+        type: 'extract_functions',
+        priority: 'high',
+        description: `${largeFunctions.length} functions are too large and should be split`,
+        boundaries: largeFunctions.map(f => ({ name: f.name, lineCount: f.lineCount }))
+      });
+    }
+    
+    // Large classes
+    const largeClasses = result.getBoundariesByType(BOUNDARY_TYPES.CLASS)
+      .filter(c => c.lineCount > 200);
+    
+    if (largeClasses.length > 0) {
+      recommendations.push({
+        type: 'split_classes',
+        priority: 'medium',
+        description: `${largeClasses.length} classes are too large and should be split`,
+        boundaries: largeClasses.map(c => ({ name: c.name, lineCount: c.lineCount }))
+      });
+    }
+    
+    // Utility extraction
+    const utilities = result.getBoundariesByType(BOUNDARY_TYPES.UTILITY);
+    if (utilities.length === 0 && result.metadata.totalBoundaries > 5) {
+      recommendations.push({
+        type: 'extract_utilities',
+        priority: 'low',
+        description: 'Consider extracting utility functions to separate modules',
+        boundaries: []
+      });
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = {
+  BoundaryDetector,
+  BoundaryDetectionResult,
+  Boundary,
+  BOUNDARY_TYPES
+};