vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/import-models.js

@@ -0,0 +1,189 @@
+/**
+ * Import Statement Models
+ * 
+ * Data models for import statements and management.
+ */
+
+/**
+ * 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;
+  }
+
+  markUsed() {
+    this.metadata.used = true;
+  }
+
+  markUnused() {
+    this.metadata.unused = true;
+  }
+
+  getSummary() {
+    return {
+      type: this.type,
+      module: this.module,
+      specifier: this.specifier,
+      isDefault: this.isDefault,
+      isRelative: this.isRelative,
+      lineNumber: this.lineNumber
+    };
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      module: this.module,
+      specifier: this.specifier,
+      isDefault: this.isDefault,
+      isTypeOnly: this.isTypeOnly,
+      isRelative: this.isRelative,
+      originalStatement: this.originalStatement,
+      lineNumber: this.lineNumber,
+      metadata: this.metadata
+    };
+  }
+}
+
+/**
+ * Import dependency class
+ */
+class ImportDependency {
+  constructor(module, sourceFile, targetFile) {
+    this.module = module;
+    this.sourceFile = sourceFile;
+    this.targetFile = targetFile;
+    this.dependencies = [];
+    this.dependents = [];
+    this.isCircular = false;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      resolved: false,
+      error: null
+    };
+  }
+
+  addDependency(dependency) {
+    if (!this.dependencies.find(dep => dep.module === dependency.module)) {
+      this.dependencies.push(dependency);
+    }
+  }
+
+  addDependent(dependent) {
+    if (!this.dependents.find(dep => dep.module === dependent.module)) {
+      this.dependents.push(dependent);
+    }
+  }
+
+  markCircular() {
+    this.isCircular = true;
+  }
+
+  markResolved() {
+    this.metadata.resolved = true;
+  }
+
+  setError(error) {
+    this.metadata.error = error;
+  }
+
+  getSummary() {
+    return {
+      module: this.module,
+      sourceFile: this.sourceFile,
+      targetFile: this.targetFile,
+      dependenciesCount: this.dependencies.length,
+      dependentsCount: this.dependents.length,
+      isCircular: this.isCircular,
+      isResolved: this.metadata.resolved
+    };
+  }
+}
+
+/**
+ * Import group class
+ */
+class ImportGroup {
+  constructor(type) {
+    this.type = type;
+    this.imports = [];
+    this.order = 0;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      sorted: false
+    };
+  }
+
+  addImport(importStatement) {
+    this.imports.push(importStatement);
+  }
+
+  removeImport(importStatement) {
+    this.imports = this.imports.filter(imp => imp !== importStatement);
+  }
+
+  sortImports() {
+    this.imports.sort((a, b) => {
+      // Sort by module name, then by specifier
+      if (a.module !== b.module) {
+        return a.module.localeCompare(b.module);
+      }
+      return (a.specifier || '').localeCompare(b.specifier || '');
+    });
+    this.metadata.sorted = true;
+  }
+
+  getImportCount() {
+    return this.imports.length;
+  }
+
+  getSummary() {
+    return {
+      type: this.type,
+      importCount: this.imports.length,
+      isSorted: this.metadata.sorted
+    };
+  }
+}
+
+module.exports = {
+  IMPORT_TYPES,
+  ImportStatement,
+  ImportDependency,
+  ImportGroup
+};

package/src/refactoring/import-parser.js

@@ -0,0 +1,306 @@
+/**
+ * Import Parser
+ * 
+ * Parses and analyzes import statements in code files.
+ */
+
+const { IMPORT_TYPES, ImportStatement, ImportGroup } = require('./import-models');
+
+/**
+ * Import Parser class
+ */
+class ImportParser {
+  constructor(options = {}) {
+    this.options = {
+      includeComments: options.includeComments !== false,
+      trackUnused: options.trackUnused !== false,
+      resolveRelative: options.resolveRelative !== false,
+      ...options
+    };
+  }
+
+  parseFile(filePath) {
+    const content = require('fs').readFileSync(filePath, 'utf8');
+    return this.parseContent(content, filePath);
+  }
+
+  parseContent(content, filePath = null) {
+    const lines = content.split('\n');
+    const imports = [];
+    
+    lines.forEach((line, index) => {
+      const importStatements = this.parseLine(line, index + 1);
+      imports.push(...importStatements);
+    });
+    
+    return {
+      imports,
+      filePath,
+      totalImports: imports.length,
+      metadata: {
+        parsedAt: new Date().toISOString(),
+        options: this.options
+      }
+    };
+  }
+
+  parseLine(line, lineNumber) {
+    const imports = [];
+    const trimmedLine = line.trim();
+    
+    // Skip empty lines and comments
+    if (!trimmedLine || this.isCommentLine(trimmedLine)) {
+      return imports;
+    }
+    
+    // Parse different import types
+    if (trimmedLine.startsWith('import ')) {
+      const es6Import = this.parseES6Import(trimmedLine, lineNumber);
+      if (es6Import) imports.push(es6Import);
+    } else if (trimmedLine.includes('require(')) {
+      const commonJSImport = this.parseCommonJSImport(trimmedLine, lineNumber);
+      if (commonJSImport) imports.push(commonJSImport);
+    } else if (trimmedLine.includes('import(')) {
+      const dynamicImport = this.parseDynamicImport(trimmedLine, lineNumber);
+      if (dynamicImport) imports.push(dynamicImport);
+    }
+    
+    return imports;
+  }
+
+  parseES6Import(line, lineNumber) {
+    // Match: import ... from 'module'
+    const importRegex = /^import\s+(.+?)\s+from\s+['"]([^'"]+)['"]\s*;?$/;
+    const match = line.match(importRegex);
+    
+    if (!match) return null;
+    
+    const importPart = match[1].trim();
+    const module = match[2];
+    
+    // Parse import specifiers
+    const { specifier, isDefault, isTypeOnly } = this.parseImportSpecifiers(importPart);
+    
+    const importStatement = new ImportStatement(
+      IMPORT_TYPES.ES6_IMPORT,
+      module,
+      specifier,
+      isDefault
+    );
+    
+    importStatement.setOriginalStatement(line);
+    importStatement.setLineNumber(lineNumber);
+    importStatement.isTypeOnly = isTypeOnly;
+    
+    return importStatement;
+  }
+
+  parseCommonJSImport(line, lineNumber) {
+    // Match: const ... = require('module')
+    const requireRegex = /(?:const|let|var)\s+(.+?)\s*=\s*require\(['"]([^'"]+)['"]\)\s*;?$/;
+    const match = line.match(requireRegex);
+    
+    if (!match) return null;
+    
+    const variableName = match[1].trim();
+    const module = match[2];
+    
+    // Check if it's a default import
+    const isDefault = !variableName.includes('{') && !variableName.includes('[');
+    
+    const importStatement = new ImportStatement(
+      IMPORT_TYPES.COMMONJS_REQUIRE,
+      module,
+      isDefault ? 'default' : variableName,
+      isDefault
+    );
+    
+    importStatement.setOriginalStatement(line);
+    importStatement.setLineNumber(lineNumber);
+    
+    return importStatement;
+  }
+
+  parseDynamicImport(line, lineNumber) {
+    // Match: import('module')
+    const dynamicRegex = /import\(['"]([^'"]+)['"]\)/;
+    const match = line.match(dynamicRegex);
+    
+    if (!match) return null;
+    
+    const module = match[1];
+    
+    const importStatement = new ImportStatement(
+      IMPORT_TYPES.DYNAMIC_IMPORT,
+      module,
+      null,
+      false
+    );
+    
+    importStatement.setOriginalStatement(line);
+    importStatement.setLineNumber(lineNumber);
+    
+    return importStatement;
+  }
+
+  parseImportSpecifiers(importPart) {
+    // Default import: import name from 'module'
+    if (!importPart.includes('{') && !importPart.includes('*')) {
+      return {
+        specifier: 'default',
+        isDefault: true,
+        isTypeOnly: false
+      };
+    }
+    
+    // Namespace import: import * as name from 'module'
+    if (importPart.includes('*')) {
+      const namespaceRegex = /\*\s+as\s+(\w+)/;
+      const match = importPart.match(namespaceRegex);
+      return {
+        specifier: match ? match[1] : '*',
+        isDefault: false,
+        isTypeOnly: false
+      };
+    }
+    
+    // Named imports: import { a, b, c } from 'module'
+    if (importPart.includes('{')) {
+      const namedRegex = /{([^}]+)}/;
+      const match = importPart.match(namedRegex);
+      const specifier = match ? match[1].trim() : '';
+      
+      return {
+        specifier,
+        isDefault: false,
+        isTypeOnly: importPart.includes('type')
+      };
+    }
+    
+    return {
+      specifier: importPart,
+      isDefault: false,
+      isTypeOnly: false
+    };
+  }
+
+  isCommentLine(line) {
+    return line.startsWith('//') || line.startsWith('/*') || line.startsWith('*');
+  }
+
+  groupImportsByType(imports) {
+    const groups = new Map();
+    
+    imports.forEach(importStatement => {
+      const type = this.getImportGroupType(importStatement);
+      
+      if (!groups.has(type)) {
+        groups.set(type, new ImportGroup(type));
+      }
+      
+      groups.get(type).addImport(importStatement);
+    });
+    
+    // Sort each group
+    groups.forEach(group => group.sortImports());
+    
+    return Array.from(groups.values());
+  }
+
+  getImportGroupType(importStatement) {
+    if (importStatement.isRelative) {
+      return 'relative';
+    } else if (importStatement.module.startsWith('node:')) {
+      return 'node';
+    } else if (importStatement.module.startsWith('@')) {
+      return 'scoped';
+    } else {
+      return 'external';
+    }
+  }
+
+  detectUnusedImports(imports, codeContent) {
+    if (!this.options.trackUnused) {
+      return [];
+    }
+    
+    const unusedImports = [];
+    
+    imports.forEach(importStatement => {
+      if (!this.isImportUsed(importStatement, codeContent)) {
+        importStatement.markUnused();
+        unusedImports.push(importStatement);
+      }
+    });
+    
+    return unusedImports;
+  }
+
+  isImportUsed(importStatement, codeContent) {
+    const name = importStatement.specifier || importStatement.module;
+    
+    // Simple usage detection (in real scenario, use AST parsing)
+    const usageRegex = new RegExp(`\\b${name}\\b`, 'g');
+    const matches = codeContent.match(usageRegex);
+    
+    // Count matches excluding the import statement itself
+    const nonImportMatches = matches ? matches.filter(match => 
+      !match.includes('import') && !match.includes('require')
+    ) : [];
+    
+    return nonImportMatches.length > 0;
+  }
+
+  resolveRelativeImports(imports, filePath) {
+    if (!this.options.resolveRelative) {
+      return imports;
+    }
+    
+    const path = require('path');
+    const fileDir = path.dirname(filePath);
+    
+    return imports.map(importStatement => {
+      if (importStatement.isRelative) {
+        const resolvedPath = path.resolve(fileDir, importStatement.module);
+        importStatement.module = resolvedPath;
+      }
+      return importStatement;
+    });
+  }
+
+  getParserInfo() {
+    return {
+      supportedTypes: Object.values(IMPORT_TYPES),
+      defaultOptions: this.options,
+      features: [
+        'ES6 import parsing',
+        'CommonJS require parsing',
+        'dynamic import parsing',
+        'import grouping',
+        'unused import detection',
+        'relative path resolution'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new ImportParser({
+      includeComments: true,
+      trackUnused: true,
+      resolveRelative: false,
+      ...config
+    });
+  }
+
+  static createForRefactoring(config = {}) {
+    return new ImportParser({
+      includeComments: false,
+      trackUnused: true,
+      resolveRelative: true,
+      ...config
+    });
+  }
+}
+
+module.exports = ImportParser;