vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/analysis/boundary-scanner.js

@@ -0,0 +1,609 @@
+/**
+ * Boundary Scanner
+ * 
+ * Scans source code to detect logical boundaries.
+ */
+
+const { BOUNDARY_TYPES, createBoundary, validateBoundary } = require('./boundary-utils');
+
+/**
+ * Boundary Scanner class
+ */
+class BoundaryScanner {
+  constructor(options = {}) {
+    this.options = {
+      includeComments: options.includeComments !== false,
+      includeImports: options.includeImports !== false,
+      includeExports: options.includeExports !== false,
+      minBoundarySize: options.minBoundarySize || 5,
+      ...options
+    };
+  }
+
+  /**
+   * Scan file for boundaries
+   * @param {string} content - File content
+   * @param {string} filePath - File path
+   * @returns {Object} - Scan result
+   */
+  scanFile(content, filePath) {
+    const lines = content.split('\n');
+    const boundaries = [];
+    
+    // Scan for different boundary types
+    boundaries.push(...this.scanFunctions(lines));
+    boundaries.push(...this.scanClasses(lines));
+    boundaries.push(...this.scanModules(lines));
+    boundaries.push(...this.scanBlocks(lines));
+    
+    if (this.options.includeComments) {
+      boundaries.push(...this.scanComments(lines));
+    }
+    
+    if (this.options.includeImports) {
+      boundaries.push(...this.scanImports(lines));
+    }
+    
+    if (this.options.includeExports) {
+      boundaries.push(...this.scanExports(lines));
+    }
+    
+    // Filter and validate boundaries
+    const validBoundaries = boundaries
+      .filter(b => b.size >= this.options.minBoundarySize)
+      .map(b => {
+        b.complexity = this.calculateBoundaryComplexity(b, lines);
+        return b;
+      })
+      .filter(b => validateBoundary(b).isValid);
+    
+    return {
+      filePath,
+      boundaries: validBoundaries,
+      metadata: this.generateScanMetadata(validBoundaries, lines)
+    };
+  }
+
+  /**
+   * Scan for functions
+   * @param {Array} lines - File lines
+   * @returns {Array} - Function boundaries
+   */
+  scanFunctions(lines) {
+    const functions = [];
+    const functionPatterns = [
+      /^(\s*)function\s+(\w+)\s*\(/,
+      /^(\s*)(async\s+)?function\s+(\w+)\s*\(/,
+      /^(\s*)(\w+)\s*:\s*function\s*\(/,
+      /^(\s*)(const|let|var)\s+(\w+)\s*=\s*(async\s+)?function\s*\(/,
+      /^(\s*)(\w+)\s*\([^)]*\)\s*{/,
+      /^(\s*)=>\s*{/
+    ];
+    
+    lines.forEach((line, index) => {
+      functionPatterns.forEach(pattern => {
+        const match = line.match(pattern);
+        if (match) {
+          const indent = match[1] || '';
+          const name = match[match.length - 1] || 'anonymous';
+          const start = index + 1;
+          const end = this.findFunctionEnd(lines, index);
+          
+          if (end > start) {
+            functions.push(createBoundary(
+              BOUNDARY_TYPES.FUNCTION,
+              start,
+              end,
+              name,
+              {
+                indent: indent.length,
+                isAsync: line.includes('async'),
+                isArrow: line.includes('=>')
+              }
+            ));
+          }
+        }
+      });
+    });
+    
+    return functions;
+  }
+
+  /**
+   * Scan for classes
+   * @param {Array} lines - File lines
+   * @returns {Array} - Class boundaries
+   */
+  scanClasses(lines) {
+    const classes = [];
+    const classPatterns = [
+      /^(\s*)class\s+(\w+)/,
+      /^(\s*)class\s+(\w+)\s+extends\s+(\w+)/,
+      /^(\s*)export\s+class\s+(\w+)/,
+      /^(\s*)export\s+default\s+class\s+(\w+)/
+    ];
+    
+    lines.forEach((line, index) => {
+      classPatterns.forEach(pattern => {
+        const match = line.match(pattern);
+        if (match) {
+          const indent = match[1] || '';
+          const name = match[2] || 'anonymous';
+          const parent = match[3] || null;
+          const start = index + 1;
+          const end = this.findClassEnd(lines, index);
+          
+          if (end > start) {
+            classes.push(createBoundary(
+              BOUNDARY_TYPES.CLASS,
+              start,
+              end,
+              name,
+              {
+                indent: indent.length,
+                parent,
+                isExport: line.includes('export')
+              }
+            ));
+          }
+        }
+      });
+    });
+    
+    return classes;
+  }
+
+  /**
+   * Scan for modules
+   * @param {Array} lines - File lines
+   * @returns {Array} - Module boundaries
+   */
+  scanModules(lines) {
+    const modules = [];
+    const modulePatterns = [
+      /^(\s*)module\.exports\s*=\s*{/,
+      /^(\s*)exports\.(\w+)\s*=/,
+      /^(\s*)export\s*{/,
+      /^(\s*)export\s+default\s*{/
+    ];
+    
+    lines.forEach((line, index) => {
+      modulePatterns.forEach(pattern => {
+        if (pattern.test(line)) {
+          const indent = line.match(/^(\s*)/)[1] || '';
+          const start = index + 1;
+          const end = this.findModuleEnd(lines, index);
+          
+          if (end > start) {
+            modules.push(createBoundary(
+              BOUNDARY_TYPES.MODULE,
+              start,
+              end,
+              `module_${index}`,
+              {
+                indent: indent.length,
+                type: line.includes('default') ? 'default' : 'named'
+              }
+            ));
+          }
+        }
+      });
+    });
+    
+    return modules;
+  }
+
+  /**
+   * Scan for blocks
+   * @param {Array} lines - File lines
+   * @returns {Array} - Block boundaries
+   */
+  scanBlocks(lines) {
+    const blocks = [];
+    const blockPatterns = [
+      /^(\s*)if\s*\(/,
+      /^(\s*)for\s*\(/,
+      /^(\s*)while\s*\(/,
+      /^(\s*)switch\s*\(/,
+      /^(\s*)try\s*{/,
+      /^(\s*)catch\s*\(/,
+      /^(\s*)finally\s*{/
+    ];
+    
+    lines.forEach((line, index) => {
+      blockPatterns.forEach(pattern => {
+        if (pattern.test(line)) {
+          const indent = line.match(/^(\s*)/)[1] || '';
+          const type = pattern.source.replace(/\\s\*/g, '').replace(/[()]/g, '');
+          const start = index + 1;
+          const end = this.findBlockEnd(lines, index);
+          
+          if (end > start) {
+            blocks.push(createBoundary(
+              BOUNDARY_TYPES.BLOCK,
+              start,
+              end,
+              `${type}_${index}`,
+              {
+                indent: indent.length,
+                blockType: type
+              }
+            ));
+          }
+        }
+      });
+    });
+    
+    return blocks;
+  }
+
+  /**
+   * Scan for comments
+   * @param {Array} lines - File lines
+   * @returns {Array} - Comment boundaries
+   */
+  scanComments(lines) {
+    const comments = [];
+    const commentPatterns = [
+      /\/\*\*/,
+      /\*\//,
+      /\/\//,
+      /\/\*/,
+      /\*\//
+    ];
+    
+    let inComment = false;
+    let commentStart = 0;
+    let commentType = null;
+    
+    lines.forEach((line, index) => {
+      if (!inComment) {
+        // Check for comment start
+        if (line.includes('/*')) {
+          inComment = true;
+          commentStart = index + 1;
+          commentType = 'block';
+        } else if (line.includes('//')) {
+          comments.push(createBoundary(
+            BOUNDARY_TYPES.COMMENT,
+            index + 1,
+            index + 1,
+            `line_comment_${index}`,
+            {
+              type: 'line',
+              content: line
+            }
+          ));
+        }
+      } else {
+        // Check for comment end
+        if (commentType === 'block' && line.includes('*/')) {
+          comments.push(createBoundary(
+            BOUNDARY_TYPES.COMMENT,
+            commentStart,
+            index + 1,
+            `block_comment_${commentStart}`,
+            {
+              type: 'block',
+              content: lines.slice(commentStart - 1, index + 1).join('\n')
+            }
+          ));
+          inComment = false;
+          commentType = null;
+        }
+      }
+    });
+    
+    return comments;
+  }
+
+  /**
+   * Scan for imports
+   * @param {Array} lines - File lines
+   * @returns {Array} - Import boundaries
+   */
+  scanImports(lines) {
+    const imports = [];
+    const importPatterns = [
+      /^(\s*)import\s+.*\s+from\s+['"][^'"]+['"]/,  // ES6 imports
+      /^(\s*)const\s+.*=\s*require\(['"][^'"]+['"]/,  // CommonJS imports
+      /^(\s*)import\s+['"][^'"]+['"]/,                    // Default imports
+      /^(\s*)require\(['"][^'"]+['"]/
+    ];
+    
+    lines.forEach((line, index) => {
+      importPatterns.forEach(pattern => {
+        if (pattern.test(line)) {
+          const indent = line.match(/^(\s*)/)[1] || '';
+          const moduleName = this.extractModuleName(line);
+          
+          imports.push(createBoundary(
+            BOUNDARY_TYPES.IMPORT,
+            index + 1,
+            index + 1,
+            `import_${moduleName}`,
+            {
+              indent: indent.length,
+              module: moduleName,
+              type: line.includes('import') ? 'es6' : 'commonjs'
+            }
+          ));
+        }
+      });
+    });
+    
+    return imports;
+  }
+
+  /**
+   * Scan for exports
+   * @param {Array} lines - File lines
+   * @returns {Array} - Export boundaries
+   */
+  scanExports(lines) {
+    const exports = [];
+    const exportPatterns = [
+      /^(\s*)export\s+(default\s+)?\w+/,
+      /^(\s*)module\.exports\s*=\s*\w+/,
+      /^(\s*)exports\.\w+\s*=/,
+      /^(\s*)export\s*{/
+    ];
+    
+    lines.forEach((line, index) => {
+      exportPatterns.forEach(pattern => {
+        if (pattern.test(line)) {
+          const indent = line.match(/^(\s*)/)[1] || '';
+          const exportName = this.extractExportName(line);
+          
+          exports.push(createBoundary(
+            BOUNDARY_TYPES.EXPORT,
+            index + 1,
+            index + 1,
+            `export_${exportName}`,
+            {
+              indent: indent.length,
+              name: exportName,
+              type: line.includes('default') ? 'default' : 'named'
+            }
+          ));
+        }
+      });
+    });
+    
+    return exports;
+  }
+
+  /**
+   * Find function end
+   * @param {Array} lines - File lines
+   * @param {number} startIndex - Start index
+   * @returns {number} - End line number
+   */
+  findFunctionEnd(lines, startIndex) {
+    let braceCount = 0;
+    let inFunction = false;
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.includes('{')) {
+        braceCount += (line.match(/{/g) || []).length;
+        inFunction = true;
+      }
+      
+      if (line.includes('}')) {
+        braceCount -= (line.match(/}/g) || []).length;
+      }
+      
+      if (inFunction && braceCount === 0) {
+        return i + 1;
+      }
+    }
+    
+    return lines.length;
+  }
+
+  /**
+   * Find class end
+   * @param {Array} lines - File lines
+   * @param {number} startIndex - Start index
+   * @returns {number} - End line number
+   */
+  findClassEnd(lines, startIndex) {
+    let braceCount = 0;
+    let inClass = false;
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.includes('{')) {
+        braceCount += (line.match(/{/g) || []).length;
+        inClass = true;
+      }
+      
+      if (line.includes('}')) {
+        braceCount -= (line.match(/}/g) || []).length;
+      }
+      
+      if (inClass && braceCount === 0) {
+        return i + 1;
+      }
+    }
+    
+    return lines.length;
+  }
+
+  /**
+   * Find module end
+   * @param {Array} lines - File lines
+   * @param {number} startIndex - Start index
+   * @returns {number} - End line number
+   */
+  findModuleEnd(lines, startIndex) {
+    // Module typically ends at end of file or next export/module
+    for (let i = startIndex + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (/^\s*(export|module\.exports)/.test(line)) {
+        return i;
+      }
+    }
+    
+    return lines.length;
+  }
+
+  /**
+   * Find block end
+   * @param {Array} lines - File lines
+   * @param {number} startIndex - Start index
+   * @returns {number} - End line number
+   */
+  findBlockEnd(lines, startIndex) {
+    let braceCount = 0;
+    let inBlock = false;
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.includes('{')) {
+        braceCount += (line.match(/{/g) || []).length;
+        inBlock = true;
+      }
+      
+      if (line.includes('}')) {
+        braceCount -= (line.match(/}/g) || []).length;
+      }
+      
+      if (inBlock && braceCount === 0) {
+        return i + 1;
+      }
+    }
+    
+    return lines.length;
+  }
+
+  /**
+   * Extract module name from import line
+   * @param {string} line - Import line
+   * @returns {string} - Module name
+   */
+  extractModuleName(line) {
+    const match = line.match(/(?:from\s+|require\()['"]([^'"]+)['"]/);
+    return match ? match[1] : 'unknown';
+  }
+
+  /**
+   * Extract export name from export line
+   * @param {string} line - Export line
+   * @returns {string} - Export name
+   */
+  extractExportName(line) {
+    const match = line.match(/(?:export\s+(?:default\s+)?|module\.exports\s*=|exports\.)(\w+)/);
+    return match ? match[1] : 'unknown';
+  }
+
+  /**
+   * Calculate boundary complexity
+   * @param {Object} boundary - Boundary object
+   * @param {Array} lines - File lines
+   * @returns {number} - Complexity score
+   */
+  calculateBoundaryComplexity(boundary, lines) {
+    const boundaryLines = lines.slice(boundary.start - 1, boundary.end);
+    let complexity = 1;
+    
+    // Count control structures
+    const controlStructures = ['if', 'for', 'while', 'switch', 'try', 'catch'];
+    boundaryLines.forEach(line => {
+      controlStructures.forEach(struct => {
+        if (new RegExp(`\\b${struct}\\b`).test(line)) {
+          complexity += 0.5;
+        }
+      });
+    });
+    
+    // Count nested structures
+    const maxNesting = this.calculateMaxNesting(boundaryLines);
+    complexity += maxNesting * 0.3;
+    
+    return Math.round(complexity);
+  }
+
+  /**
+   * Calculate maximum nesting level
+   * @param {Array} lines - Boundary lines
+   * @returns {number} - Maximum nesting level
+   */
+  calculateMaxNesting(lines) {
+    let maxNesting = 0;
+    let currentNesting = 0;
+    
+    lines.forEach(line => {
+      const opens = (line.match(/{/g) || []).length;
+      const closes = (line.match(/}/g) || []).length;
+      
+      currentNesting += opens - closes;
+      maxNesting = Math.max(maxNesting, currentNesting);
+    });
+    
+    return maxNesting;
+  }
+
+  /**
+   * Generate scan metadata
+   * @param {Array} boundaries - Detected boundaries
+   * @param {Array} lines - File lines
+   * @returns {Object} - Scan metadata
+   */
+  generateScanMetadata(boundaries, lines) {
+    const byType = {};
+    boundaries.forEach(boundary => {
+      byType[boundary.type] = (byType[boundary.type] || 0) + 1;
+    });
+    
+    return {
+      totalLines: lines.length,
+      totalBoundaries: boundaries.length,
+      byType,
+      averageBoundarySize: boundaries.length > 0 ? 
+        boundaries.reduce((sum, b) => sum + b.size, 0) / boundaries.length : 0,
+      scanOptions: this.options
+    };
+  }
+
+  /**
+   * Get scanner information
+   * @returns {Object} - Scanner info
+   */
+  getScannerInfo() {
+    return {
+      supportedTypes: Object.values(BOUNDARY_TYPES),
+      defaultOptions: this.options,
+      features: [
+        'function detection',
+        'class detection',
+        'module detection',
+        'block detection',
+        'comment detection',
+        'import/export detection'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  /**
+   * Create scanner with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {BoundaryScanner} - Scanner instance
+   */
+  static createDefault(config = {}) {
+    return new BoundaryScanner({
+      includeComments: true,
+      includeImports: true,
+      includeExports: true,
+      minBoundarySize: 5,
+      ...config
+    });
+  }
+}
+
+module.exports = BoundaryScanner;

package/src/analysis/boundary-types.js

@@ -0,0 +1,118 @@
+/**
+ * Boundary Detection - Types
+ * 
+ * Contains boundary detection types and result classes.
+ */
+
+/**
+ * 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;
+  }
+
+  getSummary() {
+    return {
+      type: this.type,
+      name: this.name,
+      startLine: this.startLine,
+      endLine: this.endLine,
+      lineCount: this.lineCount,
+      complexity: this.complexity,
+      dependencyCount: this.dependencies.length,
+      exportCount: this.exports.length,
+      commentCount: this.comments.length
+    };
+  }
+}
+
+module.exports = {
+  BOUNDARY_TYPES,
+  BoundaryDetectionResult,
+  Boundary
+};