vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/import-manager.js

@@ -0,0 +1,774 @@
+/**
+ * Import Manager
+ * 
+ * Manages import statement updates during refactoring operations.
+ * Handles import resolution, organization, and dependency tracking.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Import types
+ */
+const IMPORT_TYPES = {
+  ES6_IMPORT: 'es6_import',
+  COMMONJS_REQUIRE: 'commonjs_require',
+  DYNAMIC_IMPORT: 'dynamic_import',
+  TYPESCRIPT_IMPORT: 'typescript_import'
+};
+
+/**
+ * Import statement class
+ */
+class ImportStatement {
+  constructor(type, module, specifier = null, isDefault = false) {
+    this.type = type;
+    this.module = module;
+    this.specifier = specifier;
+    this.isDefault = isDefault;
+    this.isTypeOnly = false;
+    this.isRelative = this.isRelativeModule(module);
+    this.originalStatement = '';
+    this.lineNumber = 0;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      used: false,
+      unused: false
+    };
+  }
+
+  isRelativeModule(module) {
+    return module.startsWith('./') || module.startsWith('../');
+  }
+
+  setOriginalStatement(statement) {
+    this.originalStatement = statement;
+  }
+
+  setLineNumber(lineNumber) {
+    this.lineNumber = lineNumber;
+  }
+
+  setTypeOnly(isTypeOnly) {
+    this.isTypeOnly = isTypeOnly;
+  }
+
+  setUsed(used) {
+    this.metadata.used = used;
+  }
+
+  setUnused(unused) {
+    this.metadata.unused = unused;
+  }
+
+  generateStatement() {
+    switch (this.type) {
+      case IMPORT_TYPES.ES6_IMPORT:
+        if (this.isDefault) {
+          return `import ${this.specifier} from '${this.module}';`;
+        } else if (this.specifier) {
+          return `import { ${this.specifier} } from '${this.module}';`;
+        } else {
+          return `import '${this.module}';`;
+        }
+      
+      case IMPORT_TYPES.COMMONJS_REQUIRE:
+        if (this.specifier) {
+          return `const ${this.specifier} = require('${this.module}');`;
+        } else {
+          return `require('${this.module}');`;
+        }
+      
+      case IMPORT_TYPES.DYNAMIC_IMPORT:
+        return `import('${this.module}')`;
+      
+      case IMPORT_TYPES.TYPESCRIPT_IMPORT:
+        const typePrefix = this.isTypeOnly ? 'type ' : '';
+        if (this.isDefault) {
+          return `import ${typePrefix}${this.specifier} from '${this.module}';`;
+        } else if (this.specifier) {
+          return `import ${typePrefix}{ ${this.specifier} } from '${this.module}';`;
+        } else {
+          return `import '${this.module}';`;
+        }
+      
+      default:
+        return this.originalStatement;
+    }
+  }
+
+  getSummary() {
+    return {
+      type: this.type,
+      module: this.module,
+      specifier: this.specifier,
+      isDefault: this.isDefault,
+      isRelative: this.isRelative,
+      isUsed: this.metadata.used,
+      isUnused: this.metadata.unused,
+      lineNumber: this.lineNumber
+    };
+  }
+}
+
+/**
+ * Import manager result class
+ */
+class ImportManagerResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.originalImports = [];
+    this.updatedImports = [];
+    this.addedImports = [];
+    this.removedImports = [];
+    this.unusedImports = [];
+    this.success = false;
+    this.errors = [];
+    this.warnings = [];
+    this.metadata = {
+      processedAt: new Date().toISOString(),
+      importsAdded: 0,
+      importsRemoved: 0,
+      importsUpdated: 0
+    };
+  }
+
+  addOriginalImport(importStmt) {
+    this.originalImports.push(importStmt);
+  }
+
+  addUpdatedImport(importStmt) {
+    this.updatedImports.push(importStmt);
+  }
+
+  addAddedImport(importStmt) {
+    this.addedImports.push(importStmt);
+    this.metadata.importsAdded++;
+  }
+
+  addRemovedImport(importStmt) {
+    this.removedImports.push(importStmt);
+    this.metadata.importsRemoved++;
+  }
+
+  addUnusedImport(importStmt) {
+    this.unusedImports.push(importStmt);
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  setSuccess(success) {
+    this.success = success;
+  }
+
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      success: this.success,
+      originalImportCount: this.originalImports.length,
+      updatedImportCount: this.updatedImports.length,
+      addedImportCount: this.addedImports.length,
+      removedImportCount: this.removedImports.length,
+      unusedImportCount: this.unusedImports.length,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+
+/**
+ * Import manager class
+ */
+class ImportManager {
+  constructor(options = {}) {
+    this.options = {
+      organizeImports: true,
+      removeUnused: true,
+      sortImports: true,
+      groupImports: true,
+      preserveComments: true,
+      updateRelativePaths: true,
+      ...options
+    };
+  }
+
+  /**
+   * Update imports in a file after refactoring
+   */
+  async updateImports(filePath, changes = []) {
+    const result = new ImportManagerResult(filePath);
+    
+    try {
+      // Read file content
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Parse existing imports
+      const existingImports = this.parseImports(lines);
+      for (const imp of existingImports) {
+        result.addOriginalImport(imp);
+      }
+      
+      // Apply changes
+      const updatedImports = this.applyChanges(existingImports, changes);
+      
+      // Detect unused imports
+      const unusedImports = this.detectUnusedImports(content, updatedImports);
+      for (const imp of unusedImports) {
+        result.addUnusedImport(imp);
+      }
+      
+      // Remove unused if enabled
+      let finalImports = updatedImports;
+      if (this.options.removeUnused) {
+        finalImports = updatedImports.filter(imp => !unusedImports.includes(imp));
+        for (const imp of unusedImports) {
+          result.addRemovedImport(imp);
+        }
+      }
+      
+      // Organize imports if enabled
+      if (this.options.organizeImports) {
+        finalImports = this.organizeImports(finalImports);
+      }
+      
+      // Generate updated content
+      const updatedContent = this.generateUpdatedContent(content, existingImports, finalImports);
+      
+      // Write updated file
+      fs.writeFileSync(filePath, updatedContent, 'utf8');
+      
+      // Set results
+      for (const imp of finalImports) {
+        result.addUpdatedImport(imp);
+      }
+      
+      result.setSuccess(true);
+      
+    } catch (error) {
+      result.addError(error);
+      result.setSuccess(false);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Parse import statements from file lines
+   */
+  parseImports(lines) {
+    const imports = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // ES6 imports
+      const es6Match = line.match(/^import\s+(.+?)\s+from\s+['"]([^'"]+)['"];?\s*$/);
+      if (es6Match) {
+        const importStmt = new ImportStatement(IMPORT_TYPES.ES6_IMPORT, es6Match[2]);
+        importStmt.setOriginalStatement(line);
+        importStmt.setLineNumber(i + 1);
+        
+        // Parse specifier
+        const specifierPart = es6Match[1].trim();
+        if (specifierPart.startsWith('type ')) {
+          importStmt.setTypeOnly(true);
+          importStmt.type = IMPORT_TYPES.TYPESCRIPT_IMPORT;
+        }
+        
+        if (specifierPart === 'default' || !specifierPart.includes('{')) {
+          importStmt.isDefault = true;
+          importStmt.specifier = specifierPart.replace('type ', '').trim();
+        } else {
+          const namedMatch = specifierPart.match(/\{\s*(.+?)\s*\}/);
+          if (namedMatch) {
+            importStmt.specifier = namedMatch[1].trim();
+          }
+        }
+        
+        imports.push(importStmt);
+        continue;
+      }
+      
+      // CommonJS requires
+      const cjsMatch = line.match(/^const\s+(.+?)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\);?\s*$/);
+      if (cjsMatch) {
+        const importStmt = new ImportStatement(IMPORT_TYPES.COMMONJS_REQUIRE, cjsMatch[2]);
+        importStmt.setOriginalStatement(line);
+        importStmt.setLineNumber(i + 1);
+        importStmt.specifier = cjsMatch[1].trim();
+        imports.push(importStmt);
+        continue;
+      }
+      
+      // Bare require
+      const bareRequireMatch = line.match(/^require\s*\(\s*['"]([^'"]+)['"]\s*\);?\s*$/);
+      if (bareRequireMatch) {
+        const importStmt = new ImportStatement(IMPORT_TYPES.COMMONJS_REQUIRE, bareRequireMatch[1]);
+        importStmt.setOriginalStatement(line);
+        importStmt.setLineNumber(i + 1);
+        imports.push(importStmt);
+        continue;
+      }
+      
+      // Dynamic imports
+      const dynamicMatch = line.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+      if (dynamicMatch) {
+        const importStmt = new ImportStatement(IMPORT_TYPES.DYNAMIC_IMPORT, dynamicMatch[1]);
+        importStmt.setOriginalStatement(line);
+        importStmt.setLineNumber(i + 1);
+        imports.push(importStmt);
+      }
+    }
+    
+    return imports;
+  }
+
+  /**
+   * Apply changes to imports
+   */
+  applyChanges(existingImports, changes) {
+    let updatedImports = [...existingImports];
+    
+    for (const change of changes) {
+      switch (change.type) {
+        case 'add':
+          const newImport = this.createImportFromChange(change);
+          if (newImport && !this.importExists(updatedImports, newImport)) {
+            updatedImports.push(newImport);
+          }
+          break;
+          
+        case 'remove':
+          updatedImports = updatedImports.filter(imp => 
+            imp.module !== change.module && 
+            imp.specifier !== change.specifier
+          );
+          break;
+          
+        case 'update':
+          updatedImports = updatedImports.map(imp => {
+            if (imp.module === change.oldModule && imp.specifier === change.oldSpecifier) {
+              const updatedImport = new ImportStatement(imp.type, change.newModule || imp.module, change.newSpecifier || imp.specifier, imp.isDefault);
+              updatedImport.setLineNumber(imp.lineNumber);
+              return updatedImport;
+            }
+            return imp;
+          });
+          break;
+          
+        case 'move':
+          // Update relative paths for moved files
+          if (change.oldPath && change.newPath) {
+            updatedImports = updatedImports.map(imp => {
+              if (imp.isRelative && imp.module.includes(change.oldPath)) {
+                const updatedPath = this.updateRelativePath(imp.module, change.oldPath, change.newPath);
+                const updatedImport = new ImportStatement(imp.type, updatedPath, imp.specifier, imp.isDefault);
+                updatedImport.setLineNumber(imp.lineNumber);
+                return updatedImport;
+              }
+              return imp;
+            });
+          }
+          break;
+      }
+    }
+    
+    return updatedImports;
+  }
+
+  /**
+   * Create import from change object
+   */
+  createImportFromChange(change) {
+    const type = change.importType || IMPORT_TYPES.ES6_IMPORT;
+    const importStmt = new ImportStatement(type, change.module, change.specifier, change.isDefault);
+    
+    if (change.isTypeOnly) {
+      importStmt.setTypeOnly(true);
+      if (type === IMPORT_TYPES.ES6_IMPORT) {
+        importStmt.type = IMPORT_TYPES.TYPESCRIPT_IMPORT;
+      }
+    }
+    
+    return importStmt;
+  }
+
+  /**
+   * Check if import already exists
+   */
+  importExists(imports, newImport) {
+    return imports.some(imp => 
+      imp.module === newImport.module && 
+      imp.specifier === newImport.specifier &&
+      imp.type === newImport.type
+    );
+  }
+
+  /**
+   * Update relative path
+   */
+  updateRelativePath(currentPath, oldBasePath, newBasePath) {
+    // Resolve the current path relative to old base
+    const absolutePath = path.resolve(path.dirname(oldBasePath), currentPath);
+    
+    // Calculate new relative path
+    const newRelativePath = path.relative(path.dirname(newBasePath), absolutePath);
+    
+    // Ensure forward slashes and add ./ if needed
+    const normalizedPath = newRelativePath.replace(/\\/g, '/');
+    return normalizedPath.startsWith('.') ? normalizedPath : `./${normalizedPath}`;
+  }
+
+  /**
+   * Detect unused imports
+   */
+  detectUnusedImports(content, imports) {
+    const unused = [];
+    
+    for (const imp of imports) {
+      if (!this.isImportUsed(content, imp)) {
+        imp.setUnused(true);
+        unused.push(imp);
+      } else {
+        imp.setUsed(true);
+      }
+    }
+    
+    return unused;
+  }
+
+  /**
+   * Check if import is used in content
+   */
+  isImportUsed(content, importStmt) {
+    if (!importStmt.specifier) {
+      // Side-effect imports are always considered used
+      return true;
+    }
+    
+    // For default imports, check for the specifier name
+    if (importStmt.isDefault) {
+      const regex = new RegExp(`\\b${importStmt.specifier}\\b`, 'g');
+      return regex.test(content);
+    }
+    
+    // For named imports, check each imported name
+    const names = importStmt.specifier.split(',').map(name => name.trim().split(' as ')[0]);
+    for (const name of names) {
+      const regex = new RegExp(`\\b${name}\\b`, 'g');
+      if (regex.test(content)) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Organize imports
+   */
+  organizeImports(imports) {
+    if (!this.options.sortImports && !this.options.groupImports) {
+      return imports;
+    }
+    
+    // Group imports by type and source
+    const groups = {
+      node_builtin: [],
+      third_party: [],
+      relative: [],
+      absolute: [],
+      type: [],
+      other: []
+    };
+    
+    for (const imp of imports) {
+      const group = this.getImportGroup(imp);
+      groups[group].push(imp);
+    }
+    
+    // Sort within groups
+    if (this.options.sortImports) {
+      for (const group of Object.values(groups)) {
+        group.sort((a, b) => {
+          // Sort by module, then by specifier
+          if (a.module !== b.module) {
+            return a.module.localeCompare(b.module);
+          }
+          return (a.specifier || '').localeCompare(b.specifier || '');
+        });
+      }
+    }
+    
+    // Flatten groups
+    const organized = [];
+    const groupOrder = ['node_builtin', 'third_party', 'absolute', 'relative', 'type', 'other'];
+    
+    for (const groupName of groupOrder) {
+      if (groups[groupName].length > 0) {
+        organized.push(...groups[groupName]);
+      }
+    }
+    
+    return organized;
+  }
+
+  /**
+   * Get import group for an import
+   */
+  getImportGroup(importStmt) {
+    if (importStmt.isTypeOnly) {
+      return 'type';
+    }
+    
+    if (importStmt.isRelative) {
+      return 'relative';
+    }
+    
+    // Node.js built-in modules
+    const nodeBuiltins = [
+      'fs', 'path', 'http', 'https', 'url', 'querystring', 'util', 'events',
+      'stream', 'buffer', 'child_process', 'cluster', 'os', 'crypto', 'tls',
+      'net', 'dgram', 'dns', 'readline', 'repl', 'vm', 'zlib', 'console'
+    ];
+    
+    if (nodeBuiltins.includes(importStmt.module)) {
+      return 'node_builtin';
+    }
+    
+    // Third-party (starts with @ or doesn't contain .)
+    if (importStmt.module.startsWith('@') || !importStmt.module.includes('.')) {
+      return 'third_party';
+    }
+    
+    // Absolute paths
+    if (importStmt.module.startsWith('/')) {
+      return 'absolute';
+    }
+    
+    return 'other';
+  }
+
+  /**
+   * Generate updated content with new imports
+   */
+  generateUpdatedContent(originalContent, originalImports, updatedImports) {
+    const lines = originalContent.split('\n');
+    
+    // Find import section
+    const importSection = this.findImportSection(lines, originalImports);
+    
+    if (importSection.start === -1) {
+      // No imports found, add at the beginning
+      const importLines = updatedImports.map(imp => imp.generateStatement());
+      return [...importLines, '', ...lines].join('\n');
+    }
+    
+    // Replace import section
+    const beforeImports = lines.slice(0, importSection.start);
+    const afterImports = lines.slice(importSection.end + 1);
+    
+    const importLines = updatedImports.map(imp => imp.generateStatement());
+    
+    // Add empty lines around imports if they don't exist
+    if (importLines.length > 0) {
+      if (beforeImports.length > 0 && beforeImports[beforeImports.length - 1].trim() !== '') {
+        importLines.unshift('');
+      }
+      if (afterImports.length > 0 && afterImports[0].trim() !== '') {
+        importLines.push('');
+      }
+    }
+    
+    return [...beforeImports, ...importLines, ...afterImports].join('\n');
+  }
+
+  /**
+   * Find import section in lines
+   */
+  findImportSection(lines, imports) {
+    if (imports.length === 0) {
+      return { start: -1, end: -1 };
+    }
+    
+    const start = Math.min(...imports.map(imp => imp.lineNumber - 1));
+    const end = Math.max(...imports.map(imp => imp.lineNumber - 1));
+    
+    return { start, end };
+  }
+
+  /**
+   * Update imports for multiple files
+   */
+  async updateImportsInFiles(filePaths, changes) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = await this.updateImports(filePath, changes);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Add import to file
+   */
+  async addImport(filePath, module, specifier = null, options = {}) {
+    const change = {
+      type: 'add',
+      module,
+      specifier,
+      isDefault: options.isDefault || false,
+      isTypeOnly: options.isTypeOnly || false,
+      importType: options.importType || IMPORT_TYPES.ES6_IMPORT
+    };
+    
+    return await this.updateImports(filePath, [change]);
+  }
+
+  /**
+   * Remove import from file
+   */
+  async removeImport(filePath, module, specifier = null) {
+    const change = {
+      type: 'remove',
+      module,
+      specifier
+    };
+    
+    return await this.updateImports(filePath, [change]);
+  }
+
+  /**
+   * Update import paths after file moves
+   */
+  async updateImportPathsAfterMove(movedFiles) {
+    const results = [];
+    
+    for (const movedFile of movedFiles) {
+      // Find files that might import the moved file
+      const dependentFiles = this.findDependentFiles(movedFile.oldPath);
+      
+      for (const depFile of dependentFiles) {
+        const change = {
+          type: 'move',
+          oldPath: movedFile.oldPath,
+          newPath: movedFile.newPath
+        };
+        
+        const result = await this.updateImports(depFile, [change]);
+        results.push(result);
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Find files that depend on a given file
+   */
+  findDependentFiles(targetPath) {
+    // This would search the codebase for files that import from targetPath
+    // For now, return empty array as placeholder
+    return [];
+  }
+
+  /**
+   * Get import statistics
+   */
+  getStatistics(results) {
+    const stats = {
+      totalFiles: results.length,
+      successful: 0,
+      failed: 0,
+      totalImportsProcessed: 0,
+      totalImportsAdded: 0,
+      totalImportsRemoved: 0,
+      totalUnusedImports: 0,
+      errors: [],
+      warnings: []
+    };
+    
+    for (const result of results) {
+      if (result.success) {
+        stats.successful++;
+      } else {
+        stats.failed++;
+      }
+      
+      stats.totalImportsProcessed += result.originalImports.length;
+      stats.totalImportsAdded += result.metadata.importsAdded;
+      stats.totalImportsRemoved += result.metadata.importsRemoved;
+      stats.totalUnusedImports += result.unusedImports.length;
+      
+      stats.errors.push(...result.errors);
+      stats.warnings.push(...result.warnings);
+    }
+    
+    return stats;
+  }
+
+  /**
+   * Validate import statements
+   */
+  validateImports(filePath) {
+    const result = new ImportManagerResult(filePath);
+    
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      const imports = this.parseImports(lines);
+      
+      for (const imp of imports) {
+        // Check if module exists
+        if (imp.isRelative) {
+          const resolvedPath = path.resolve(path.dirname(filePath), imp.module);
+          if (!fs.existsSync(resolvedPath) && !fs.existsSync(resolvedPath + '.js')) {
+            result.addWarning(`Import module not found: ${imp.module}`);
+          }
+        }
+        
+        // Check for duplicate imports
+        const duplicates = imports.filter(other => 
+          other !== imp && 
+          other.module === imp.module && 
+          other.specifier === imp.specifier
+        );
+        
+        if (duplicates.length > 0) {
+          result.addWarning(`Duplicate import: ${imp.module} - ${imp.specifier}`);
+        }
+      }
+      
+      result.setSuccess(true);
+      
+    } catch (error) {
+      result.addError(error);
+      result.setSuccess(false);
+    }
+    
+    return result;
+  }
+}
+
+module.exports = {
+  ImportManager,
+  ImportStatement,
+  ImportManagerResult,
+  IMPORT_TYPES
+};