vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/functionality-validator.js

@@ -9,26 +9,12 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
-/**
- * Validation techniques
- */
 const VALIDATION_TECHNIQUES = {
-  STATIC_ANALYSIS: 'static_analysis',
-  BEHAVIORAL_COMPARISON: 'behavioral_comparison',
-  API_COMPATIBILITY: 'api_compatibility',
-  TYPE_CHECKING: 'type_checking',
-  RUNTIME_VALIDATION: 'runtime_validation'
+  STATIC_ANALYSIS: 'static_analysis', BEHAVIORAL_COMPARISON: 'behavioral_comparison', API_COMPATIBILITY: 'api_compatibility',
+  TYPE_CHECKING: 'type_checking', RUNTIME_VALIDATION: 'runtime_validation'
 };
 
-/**
- * Validation severity levels
- */
-const VALIDATION_SEVERITY = {
-  INFO: 'info',
-  WARNING: 'warning',
-  ERROR: 'error',
-  CRITICAL: 'critical'
-};
+const VALIDATION_SEVERITY = { INFO: 'info', WARNING: 'warning', ERROR: 'error', CRITICAL: 'critical' };
 
 /**
  * Functionality validation result class
@@ -47,38 +33,24 @@ class FunctionalityValidationResult {
     };
   }
 
-  addTechniqueResult(technique, result) {
-    this.techniques.set(technique, result);
-  }
+  addTechniqueResult(technique, result) { this.techniques.set(technique, result); }
 
   addIssue(severity, message, details = null) {
-    this.issues.push({
-      severity,
-      message,
-      details,
-      timestamp: new Date().toISOString()
-    });
+    this.issues.push({ severity, message, details, timestamp: new Date().toISOString() });
   }
 
-  setSuccess(success) {
-    this.success = success;
-  }
-
-  setConfidence(confidence) {
-    this.confidence = Math.max(0, Math.min(1, confidence));
-  }
+  setSuccess(success) { this.success = success; }
+  setConfidence(confidence) { this.confidence = Math.max(0, Math.min(1, confidence)); }
 
   calculateOverallSuccess() {
     const techniqueResults = Array.from(this.techniques.values());
     const passedTechniques = techniqueResults.filter(r => r.success).length;
     const totalTechniques = techniqueResults.length;
-    
     if (totalTechniques === 0) {
       this.setSuccess(false);
       this.setConfidence(0);
       return;
     }
-    
     const successRate = passedTechniques / totalTechniques;
     this.setSuccess(successRate >= 0.8 && this.issues.filter(i => i.severity === VALIDATION_SEVERITY.ERROR || i.severity === VALIDATION_SEVERITY.CRITICAL).length === 0);
     this.setConfidence(successRate);
@@ -120,26 +92,14 @@ class TechniqueResult {
     };
   }
 
-  setSuccess(success) {
-    this.success = success;
-  }
-
-  setDuration(duration) {
-    this.duration = duration;
-  }
+  setSuccess(success) { this.success = success; }
+  setDuration(duration) { this.duration = duration; }
 
   addIssue(severity, message, details = null) {
-    this.issues.push({
-      severity,
-      message,
-      details,
-      timestamp: new Date().toISOString()
-    });
+    this.issues.push({ severity, message, details, timestamp: new Date().toISOString() });
   }
 
-  setDetails(details) {
-    this.metadata.details = details;
-  }
+  setDetails(details) { this.metadata.details = details; }
 }
 
 /**

package/src/refactoring/import-manager-refactored.js

@@ -0,0 +1,385 @@
+/**
+ * Import Manager
+ * 
+ * Manages import statement updates during refactoring operations.
+ * Handles import resolution, organization, and dependency tracking.
+ */
+
+const ImportParser = require('./import-parser');
+const { ImportStatement, ImportGroup, ImportDependency } = require('./import-models');
+
+/**
+ * Import Manager class
+ */
+class ImportManager {
+  constructor(options = {}) {
+    this.options = {
+      autoOrganize: options.autoOrganize !== false,
+      removeUnused: options.removeUnused !== false,
+      resolveRelative: options.resolveRelative !== false,
+      preserveOrder: options.preserveOrder || false,
+      ...options
+    };
+    
+    this.parser = new ImportParser(this.options);
+    this.dependencies = new Map();
+    this.history = [];
+  }
+
+  analyzeFile(filePath) {
+    const parseResult = this.parser.parseFile(filePath);
+    
+    // Analyze dependencies
+    const dependencies = this.analyzeDependencies(parseResult.imports, filePath);
+    
+    // Detect unused imports
+    const unusedImports = this.parser.detectUnusedImports(
+      parseResult.imports,
+      require('fs').readFileSync(filePath, 'utf8')
+    );
+    
+    return {
+      ...parseResult,
+      dependencies,
+      unusedImports,
+      summary: {
+        totalImports: parseResult.imports.length,
+        unusedCount: unusedImports.length,
+        dependencyCount: dependencies.length
+      }
+    };
+  }
+
+  analyzeFiles(filePaths) {
+    const results = [];
+    
+    filePaths.forEach(filePath => {
+      const analysis = this.analyzeFile(filePath);
+      results.push(analysis);
+    });
+    
+    // Build dependency graph
+    this.buildDependencyGraph(results);
+    
+    return {
+      results,
+      summary: {
+        totalFiles: filePaths.length,
+        totalImports: results.reduce((sum, r) => sum + r.totalImports, 0),
+        totalUnused: results.reduce((sum, r) => sum + r.unusedImports.length, 0),
+        totalDependencies: results.reduce((sum, r) => sum + r.dependencyCount, 0)
+      }
+    };
+  }
+
+  analyzeDependencies(imports, filePath) {
+    const dependencies = [];
+    const path = require('path');
+    
+    imports.forEach(importStatement => {
+      if (importStatement.isRelative) {
+        const resolvedPath = path.resolve(path.dirname(filePath), importStatement.module);
+        const dependency = new ImportDependency(
+          importStatement.module,
+          filePath,
+          resolvedPath
+        );
+        dependencies.push(dependency);
+      }
+    });
+    
+    return dependencies;
+  }
+
+  buildDependencyGraph(analysisResults) {
+    this.dependencies.clear();
+    
+    analysisResults.forEach(result => {
+      result.dependencies.forEach(dep => {
+        this.dependencies.set(dep.module, dep);
+      });
+    });
+    
+    // Detect circular dependencies
+    this.detectCircularDependencies();
+  }
+
+  detectCircularDependencies() {
+    const visited = new Set();
+    const recursionStack = new Set();
+    
+    for (const [module, dependency] of this.dependencies) {
+      if (this.hasCircularDependency(module, visited, recursionStack)) {
+        dependency.markCircular();
+      }
+    }
+  }
+
+  hasCircularDependency(module, visited, recursionStack) {
+    if (recursionStack.has(module)) {
+      return true; // Circular dependency detected
+    }
+    
+    if (visited.has(module)) {
+      return false; // Already processed
+    }
+    
+    visited.add(module);
+    recursionStack.add(module);
+    
+    const dependency = this.dependencies.get(module);
+    if (dependency) {
+      for (const dep of dependency.dependencies) {
+        if (this.hasCircularDependency(dep.module, visited, recursionStack)) {
+          return true;
+        }
+      }
+    }
+    
+    recursionStack.delete(module);
+    return false;
+  }
+
+  organizeImports(imports, options = {}) {
+    const organizeOptions = {
+      groupByType: options.groupByType !== false,
+      sortAlphabetically: options.sortAlphabetically !== false,
+      preserveOrder: options.preserveOrder || this.options.preserveOrder,
+      ...options
+    };
+    
+    let organizedImports = [...imports];
+    
+    if (organizeOptions.groupByType) {
+      const groups = this.parser.groupImportsByType(imports);
+      organizedImports = this.flattenGroups(groups, organizeOptions.sortAlphabetically);
+    }
+    
+    if (organizeOptions.sortAlphabetically && !organizeOptions.groupByType) {
+      organizedImports.sort((a, b) => a.module.localeCompare(b.module));
+    }
+    
+    return organizedImports;
+  }
+
+  flattenGroups(groups, sortAlphabetically) {
+    const flattened = [];
+    
+    // Define group order
+    const groupOrder = ['external', 'scoped', 'node', 'relative'];
+    
+    // Sort groups by defined order
+    groups.sort((a, b) => {
+      const aIndex = groupOrder.indexOf(a.type);
+      const bIndex = groupOrder.indexOf(b.type);
+      return aIndex - bIndex;
+    });
+    
+    groups.forEach(group => {
+      if (sortAlphabetically) {
+        group.sortImports();
+      }
+      flattened.push(...group.imports);
+    });
+    
+    return flattened;
+  }
+
+  updateImportPaths(imports, pathMappings) {
+    return imports.map(importStatement => {
+      const updatedImport = { ...importStatement };
+      
+      // Check if this import needs updating
+      const mapping = pathMappings.find(mapping => 
+        mapping.oldPath === importStatement.module
+      );
+      
+      if (mapping) {
+        updatedImport.module = mapping.newPath;
+        updatedImport.isRelative = this.isRelativeModule(mapping.newPath);
+      }
+      
+      return updatedImport;
+    });
+  }
+
+  isRelativeModule(module) {
+    return module.startsWith('./') || module.startsWith('../');
+  }
+
+  removeUnusedImports(imports, codeContent) {
+    const unusedImports = this.parser.detectUnusedImports(imports, codeContent);
+    
+    return imports.filter(importStatement => 
+      !unusedImports.includes(importStatement)
+    );
+  }
+
+  generateImportStatements(imports) {
+    return imports.map(importStatement => {
+      switch (importStatement.type) {
+        case 'es6_import':
+          return this.generateES6Import(importStatement);
+        case 'commonjs_require':
+          return this.generateCommonJSRequire(importStatement);
+        default:
+          return importStatement.originalStatement;
+      }
+    });
+  }
+
+  generateES6Import(importStatement) {
+    if (importStatement.isDefault) {
+      return `import ${importStatement.specifier || 'default'} from '${importStatement.module}';`;
+    } else if (importStatement.specifier === '*') {
+      return `import * as ${importStatement.specifier} from '${importStatement.module}';`;
+    } else {
+      return `import { ${importStatement.specifier} } from '${importStatement.module}';`;
+    }
+  }
+
+  generateCommonJSRequire(importStatement) {
+    if (importStatement.isDefault) {
+      return `const ${importStatement.specifier} = require('${importStatement.module}');`;
+    } else {
+      return `const { ${importStatement.specifier} } = require('${importStatement.module}');`;
+    }
+  }
+
+  updateFileImports(filePath, updates) {
+    const fs = require('fs');
+    const content = fs.readFileSync(filePath, 'utf8');
+    const analysis = this.analyzeFile(filePath);
+    
+    let updatedContent = content;
+    
+    // Apply updates
+    updates.forEach(update => {
+      switch (update.type) {
+        case 'organize':
+          if (this.options.autoOrganize) {
+            const organizedImports = this.organizeImports(analysis.imports, update.options);
+            updatedContent = this.replaceImportsInContent(
+              updatedContent,
+              analysis.imports,
+              organizedImports
+            );
+          }
+          break;
+          
+        case 'remove_unused':
+          if (this.options.removeUnused) {
+            const filteredImports = this.removeUnusedImports(analysis.imports, content);
+            updatedContent = this.replaceImportsInContent(
+              updatedContent,
+              analysis.imports,
+              filteredImports
+            );
+          }
+          break;
+          
+        case 'update_paths':
+          const updatedImports = this.updateImportPaths(analysis.imports, update.pathMappings);
+          updatedContent = this.replaceImportsInContent(
+            updatedContent,
+            analysis.imports,
+            updatedImports
+          );
+          break;
+      }
+    });
+    
+    // Write updated content
+    fs.writeFileSync(filePath, updatedContent, 'utf8');
+    
+    // Record in history
+    this.history.push({
+      filePath,
+      updates,
+      timestamp: new Date().toISOString(),
+      previousAnalysis: analysis
+    });
+    
+    return {
+      success: true,
+      filePath,
+      updatesApplied: updates.length,
+      newAnalysis: this.analyzeFile(filePath)
+    };
+  }
+
+  replaceImportsInContent(content, oldImports, newImports) {
+    let updatedContent = content;
+    
+    oldImports.forEach((oldImport, index) => {
+      const newImport = newImports[index];
+      if (newImport && newImport.originalStatement !== oldImport.originalStatement) {
+        const newStatement = this.generateImportStatements([newImport])[0];
+        updatedContent = updatedContent.replace(
+          oldImport.originalStatement,
+          newStatement
+        );
+      }
+    });
+    
+    return updatedContent;
+  }
+
+  getDependencyGraph() {
+    const graph = {};
+    
+    this.dependencies.forEach((dependency, module) => {
+      graph[module] = {
+        sourceFile: dependency.sourceFile,
+        targetFile: dependency.targetFile,
+        dependencies: dependency.dependencies.map(dep => dep.module),
+        isCircular: dependency.isCircular
+      };
+    });
+    
+    return graph;
+  }
+
+  getImportHistory() {
+    return this.history;
+  }
+
+  getManagerInfo() {
+    return {
+      supportedImportTypes: ['es6_import', 'commonjs_require', 'dynamic_import'],
+      defaultOptions: this.options,
+      features: [
+        'import parsing',
+        'dependency analysis',
+        'import organization',
+        'unused import detection',
+        'path updates',
+        'circular dependency detection',
+        'batch processing'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new ImportManager({
+      autoOrganize: true,
+      removeUnused: true,
+      resolveRelative: false,
+      preserveOrder: false,
+      ...config
+    });
+  }
+
+  static createForRefactoring(config = {}) {
+    return new ImportManager({
+      autoOrganize: true,
+      removeUnused: true,
+      resolveRelative: true,
+      preserveOrder: false,
+      ...config
+    });
+  }
+}
+
+module.exports = ImportManager;