vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,270 @@
+/**
+ * Utility Boundary Detection
+ */
+
+const { BOUNDARY_TYPES } = require('../boundary-types');
+
+/**
+ * Utility boundary detector
+ */
+class UtilityDetector {
+  constructor() {
+    this.patterns = this.initializePatterns();
+  }
+
+  /**
+   * Initialize detection patterns
+   * @returns {Object} Detection patterns
+   */
+  initializePatterns() {
+    return {
+      utility: [
+        /(?:const|let|var)\s+\w+\s*=\s*\([^)]*\)\s*=>/,
+        /function\s+(?:is|has|get|set|calculate|compute|parse|format|validate|check)/,
+        /(?:is|has|get|set|calculate|compute|parse|format|validate|check)\w+\s*\(/
+      ]
+    };
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Check if line is a utility function
+   * @param {string} line - Code line
+   * @returns {boolean} Whether line is utility function
+   */
+  isUtilityFunction(line) {
+    return this.patterns.utility.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;
+  }
+
+  /**
+   * 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.UTILITY) {
+      // 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 = UtilityDetector;

package/src/refactoring/circular-dependency-resolver-original.js

@@ -8,25 +8,8 @@
 const fs = require('fs');
 const path = require('path');
 
-/**
- * Dependency types
- */
-const DEPENDENCY_TYPES = {
-  IMPORT: 'import',
-  REQUIRE: 'require',
-  DYNAMIC: 'dynamic',
-  INDIRECT: 'indirect'
-};
-
-/**
- * Cycle severity levels
- */
-const CYCLE_SEVERITY = {
-  LOW: 'low',
-  MEDIUM: 'medium',
-  HIGH: 'high',
-  CRITICAL: 'critical'
-};
+const DEPENDENCY_TYPES = { IMPORT: 'import', REQUIRE: 'require', DYNAMIC: 'dynamic', INDIRECT: 'indirect' };
+const CYCLE_SEVERITY = { LOW: 'low', MEDIUM: 'medium', HIGH: 'high', CRITICAL: 'critical' };
 
 /**
  * Dependency node class
@@ -57,25 +40,11 @@ class DependencyNode {
     return match ? match[1] : 'root';
   }
 
-  addDependency(filePath, type = DEPENDENCY_TYPES.IMPORT) {
-    this.dependencies.add({ path: filePath, type });
-  }
-
-  addDependent(filePath) {
-    this.dependents.add(filePath);
-  }
-
-  hasDependency(filePath) {
-    return this.dependencies.has(filePath);
-  }
-
-  getDependencyCount() {
-    return this.dependencies.size;
-  }
-
-  getDependentCount() {
-    return this.dependents.size;
-  }
+  addDependency(filePath, type = DEPENDENCY_TYPES.IMPORT) { this.dependencies.add({ path: filePath, type }); }
+  addDependent(filePath) { this.dependents.add(filePath); }
+  hasDependency(filePath) { return this.dependencies.has(filePath); }
+  getDependencyCount() { return this.dependencies.size; }
+  getDependentCount() { return this.dependents.size; }
 }
 
 /**
@@ -103,23 +72,16 @@ class CircularDependency {
 
   calculateImpact() {
     let impact = 0;
-    
-    // Impact based on cycle length
     impact += (6 - Math.min(this.length, 6)) * 10;
-    
-    // Impact based on file types
     for (const filePath of this.cycle) {
       if (filePath.includes('packages/core')) impact += 15;
       if (filePath.includes('packages/cli')) impact += 10;
       if (filePath.includes('packages/electron-app')) impact += 8;
     }
-    
     return Math.min(100, impact);
   }
 
-  setResolution(resolution) {
-    this.resolution = resolution;
-  }
+  setResolution(resolution) { this.resolution = resolution; }
 
   getSummary() {
     return {
@@ -146,13 +108,8 @@ class ResolutionStrategy {
     this.applicable = true;
   }
 
-  addStep(step) {
-    this.steps.push(step);
-  }
-
-  setApplicable(applicable) {
-    this.applicable = applicable;
-  }
+  addStep(step) { this.steps.push(step); }
+  setApplicable(applicable) { this.applicable = applicable; }
 
   getSummary() {
     return {
@@ -184,34 +141,17 @@ class CircularDependencyResult {
     this.warnings = [];
   }
 
-  addCycle(cycle) {
-    this.cycles.push(cycle);
-  }
-
-  addStrategy(strategy) {
-    this.strategies.push(strategy);
-  }
-
-  addResolved(resolution) {
-    this.resolved.push(resolution);
-  }
-
-  addFailed(failure) {
-    this.failed.push(failure);
-  }
+  addCycle(cycle) { this.cycles.push(cycle); }
+  addStrategy(strategy) { this.strategies.push(strategy); }
+  addResolved(resolution) { this.resolved.push(resolution); }
+  addFailed(failure) { this.failed.push(failure); }
 
   addError(error) {
-    this.errors.push({
-      message: error.message,
-      timestamp: new Date().toISOString()
-    });
+    this.errors.push({ message: error.message, timestamp: new Date().toISOString() });
   }
 
   addWarning(warning) {
-    this.warnings.push({
-      message: warning,
-      timestamp: new Date().toISOString()
-    });
+    this.warnings.push({ message: warning, timestamp: new Date().toISOString() });
   }
 
   getSummary() {

package/src/refactoring/code-mover-refactored.js

@@ -0,0 +1,309 @@
+/**
+ * Code Segment Mover
+ * 
+ * Moves code segments between files while preserving functionality.
+ * Handles import updates and dependency management during moves.
+ */
+
+const { RollbackManager } = require('../utils/rollback-manager');
+const MoveExecutor = require('./move-executor');
+
+/**
+ * Code Mover class
+ */
+class CodeMover {
+  constructor(options = {}) {
+    this.options = {
+      autoBackup: options.autoBackup !== false,
+      validateSyntax: options.validateSyntax !== false,
+      updateImports: options.updateImports !== false,
+      preserveFormatting: options.preserveFormatting !== false,
+      continueOnError: options.continueOnError || false,
+      ...options
+    };
+    
+    this.executor = new MoveExecutor(this.options);
+    this.moveHistory = [];
+  }
+
+  async moveCodeSegment(moveRequest) {
+    const operation = {
+      type: 'extract',
+      source: {
+        filePath: moveRequest.sourceFile,
+        startLine: moveRequest.startLine,
+        endLine: moveRequest.endLine
+      },
+      target: {
+        filePath: moveRequest.targetFile,
+        insertPosition: moveRequest.insertPosition || 'end'
+      },
+      options: this.options
+    };
+    
+    const result = await this.executor.executeMove(operation);
+    
+    // Record in history
+    this.moveHistory.push({
+      operation,
+      result: result.getSummary(),
+      timestamp: new Date().toISOString()
+    });
+    
+    return result;
+  }
+
+  async extractFunction(functionName, sourceFile, targetFile) {
+    // Find function in source file
+    const sourceContent = await fs.promises.readFile(sourceFile, 'utf8');
+    const functionMatch = this.findFunctionDefinition(sourceContent, functionName);
+    
+    if (!functionMatch) {
+      throw new Error(`Function '${functionName}' not found in ${sourceFile}`);
+    }
+    
+    const moveRequest = {
+      sourceFile,
+      targetFile,
+      startLine: functionMatch.startLine,
+      endLine: functionMatch.endLine,
+      insertPosition: 'end'
+    };
+    
+    return await this.moveCodeSegment(moveRequest);
+  }
+
+  async extractClass(className, sourceFile, targetFile) {
+    // Find class in source file
+    const sourceContent = await fs.promises.readFile(sourceFile, 'utf8');
+    const classMatch = this.findClassDefinition(sourceContent, className);
+    
+    if (!classMatch) {
+      throw new Error(`Class '${className}' not found in ${sourceFile}`);
+    }
+    
+    const moveRequest = {
+      sourceFile,
+      targetFile,
+      startLine: classMatch.startLine,
+      endLine: classMatch.endLine,
+      insertPosition: 'end'
+    };
+    
+    return await this.moveCodeSegment(moveRequest);
+  }
+
+  async consolidateRelatedFunctions(functionNames, sourceFile, targetFile) {
+    const results = [];
+    
+    for (const functionName of functionNames) {
+      try {
+        const result = await this.extractFunction(functionName, sourceFile, targetFile);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          success: false,
+          error: error.message,
+          functionName
+        });
+      }
+    }
+    
+    return {
+      results,
+      summary: {
+        total: functionNames.length,
+        successful: results.filter(r => r.success).length,
+        failed: results.filter(r => !r.success).length
+      }
+    };
+  }
+
+  findFunctionDefinition(content, functionName) {
+    const lines = content.split('\n');
+    const functionPattern = new RegExp(`(?:function\\s+${functionName}\\s*\\(|${functionName}\\s*:\\s*function|const\\s+${functionName}\\s*=\\s*function)`, 'g');
+    
+    for (let i = 0; i < lines.length; i++) {
+      if (functionPattern.test(lines[i])) {
+        return {
+          startLine: i + 1,
+          endLine: this.findFunctionEnd(lines, i),
+          content: lines[i]
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  findClassDefinition(content, className) {
+    const lines = content.split('\n');
+    const classPattern = new RegExp(`class\\s+${className}\\s*(?:extends\\s+\\w+)?`, 'g');
+    
+    for (let i = 0; i < lines.length; i++) {
+      if (classPattern.test(lines[i])) {
+        return {
+          startLine: i + 1,
+          endLine: this.findClassEnd(lines, i),
+          content: lines[i]
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  async batchMove(moveRequests) {
+    const operations = moveRequests.map(request => ({
+      type: 'extract',
+      source: {
+        filePath: request.sourceFile,
+        startLine: request.startLine,
+        endLine: request.endLine
+      },
+      target: {
+        filePath: request.targetFile,
+        insertPosition: request.insertPosition || 'end'
+      },
+      options: this.options
+    }));
+    
+    return await this.executor.executeBatchMove(operations);
+  }
+
+  getMoveHistory() {
+    return this.moveHistory;
+  }
+
+  async rollbackLastMove() {
+    return await this.executor.rollbackLastMove();
+  }
+
+  analyzeMoveImpact(moveRequest) {
+    const operation = {
+      type: 'extract',
+      source: {
+        filePath: moveRequest.sourceFile,
+        startLine: moveRequest.startLine,
+        endLine: moveRequest.endLine
+      },
+      target: {
+        filePath: moveRequest.targetFile
+      }
+    };
+    
+    const impact = {
+      linesMoved: moveRequest.endLine - moveRequest.startLine + 1,
+      filesAffected: 2,
+      riskLevel: 'low',
+      dependencies: []
+    };
+    
+    // Risk assessment
+    if (impact.linesMoved > 50) {
+      impact.riskLevel = 'high';
+    } else if (impact.linesMoved > 20) {
+      impact.riskLevel = 'medium';
+    }
+    
+    return impact;
+  }
+
+  generateMoveReport(result) {
+    return this.executor.generateReport(result.operation, result);
+  }
+
+  getMoverInfo() {
+    return {
+      supportedOperations: [
+        'extract_function',
+        'extract_class',
+        'move_segment',
+        'batch_move',
+        'consolidate_functions'
+      ],
+      defaultOptions: this.options,
+      features: [
+        'function extraction',
+        'class extraction',
+        'import management',
+        'backup creation',
+        'rollback support',
+        'batch operations',
+        'impact analysis'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new CodeMover({
+      autoBackup: true,
+      validateSyntax: true,
+      updateImports: true,
+      preserveFormatting: true,
+      ...config
+    });
+  }
+
+  static createForRefactoring(config = {}) {
+    return new CodeMover({
+      autoBackup: true,
+      validateSyntax: true,
+      updateImports: true,
+      preserveFormatting: false,
+      continueOnError: false,
+      ...config
+    });
+  }
+}
+
+module.exports = CodeMover;