@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/engines/import-order-engine.js

@@ -1,429 +0,0 @@
-/**
- * Import Order Engine
- * Detects:
- * - Inconsistent import ordering
- * - Mixed import styles (require vs import)
- * - Circular import potential
- * - Unused imports (basic detection)
- * - Side-effect imports
- * - Type-only imports that should use 'import type'
- */
-
-const { getAST } = require("./ast-cache");
-const traverse = require("@babel/traverse").default;
-const t = require("@babel/types");
-const { shouldExcludeFile, isTestContext, hasIgnoreDirective } = require("./file-filter");
-
-/**
- * Import categories for ordering
- */
-const IMPORT_CATEGORIES = {
-  BUILTIN: 1,      // node:fs, fs, path, etc.
-  EXTERNAL: 2,     // react, lodash, @org/pkg
-  INTERNAL: 3,     // @/, ~/, #/
-  PARENT: 4,       // ../
-  SIBLING: 5,      // ./
-  INDEX: 6,        // ./index, .
-  STYLE: 7,        // .css, .scss, .less
-  TYPE: 8,         // import type
-};
-
-/**
- * Node.js built-in modules
- */
-const BUILTIN_MODULES = new Set([
-  "assert", "buffer", "child_process", "cluster", "console", "constants",
-  "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https",
-  "module", "net", "os", "path", "punycode", "querystring", "readline",
-  "repl", "stream", "string_decoder", "sys", "timers", "tls", "tty",
-  "url", "util", "vm", "zlib", "process",
-]);
-
-/**
- * Determine import category
- */
-function getImportCategory(source, isTypeOnly = false) {
-  if (isTypeOnly) return IMPORT_CATEGORIES.TYPE;
-  
-  // Style imports
-  if (/\.(css|scss|sass|less|styl)$/.test(source)) {
-    return IMPORT_CATEGORIES.STYLE;
-  }
-  
-  // Node built-in
-  if (source.startsWith("node:") || BUILTIN_MODULES.has(source)) {
-    return IMPORT_CATEGORIES.BUILTIN;
-  }
-  
-  // Internal aliases
-  if (source.startsWith("@/") || source.startsWith("~/") || source.startsWith("#/")) {
-    return IMPORT_CATEGORIES.INTERNAL;
-  }
-  
-  // Relative imports
-  if (source.startsWith("../")) {
-    return IMPORT_CATEGORIES.PARENT;
-  }
-  
-  if (source === "." || source === "./index" || source.startsWith("./index.")) {
-    return IMPORT_CATEGORIES.INDEX;
-  }
-  
-  if (source.startsWith("./")) {
-    return IMPORT_CATEGORIES.SIBLING;
-  }
-  
-  // External packages
-  return IMPORT_CATEGORIES.EXTERNAL;
-}
-
-/**
- * Get category name for display
- */
-function getCategoryName(category) {
-  const names = {
-    [IMPORT_CATEGORIES.BUILTIN]: "built-in",
-    [IMPORT_CATEGORIES.EXTERNAL]: "external",
-    [IMPORT_CATEGORIES.INTERNAL]: "internal alias",
-    [IMPORT_CATEGORIES.PARENT]: "parent",
-    [IMPORT_CATEGORIES.SIBLING]: "sibling",
-    [IMPORT_CATEGORIES.INDEX]: "index",
-    [IMPORT_CATEGORIES.STYLE]: "style",
-    [IMPORT_CATEGORIES.TYPE]: "type",
-  };
-  return names[category] || "unknown";
-}
-
-function snippetForLine(lines, line) {
-  return lines[line - 1] ? lines[line - 1].trim() : "";
-}
-
-/**
- * Analyze import order and patterns
- */
-function analyzeImportOrder(code, filePath) {
-  const findings = [];
-  
-  if (shouldExcludeFile(filePath)) return findings;
-  if (isTestContext(code, filePath)) return findings;
-  if (hasIgnoreDirective(code, "import-order")) return findings;
-  
-  const ast = getAST(code, filePath);
-  if (!ast) return findings;
-  
-  const lines = code.split("\n");
-  
-  // Collect all imports
-  const imports = [];
-  const requires = [];
-  const importedIdentifiers = new Set();
-  const usedIdentifiers = new Set();
-  let lastImportLine = 0;
-  let hasCodeBetweenImports = false;
-  
-  traverse(ast, {
-    ImportDeclaration(path) {
-      const node = path.node;
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      const source = node.source.value;
-      const isTypeOnly = node.importKind === "type";
-      const category = getImportCategory(source, isTypeOnly);
-      
-      // Track imported identifiers
-      for (const specifier of node.specifiers) {
-        if (t.isImportSpecifier(specifier) || t.isImportDefaultSpecifier(specifier)) {
-          importedIdentifiers.add(specifier.local.name);
-        } else if (t.isImportNamespaceSpecifier(specifier)) {
-          importedIdentifiers.add(specifier.local.name);
-        }
-      }
-      
-      // Check for code between imports
-      if (lastImportLine > 0 && loc.line > lastImportLine + 1) {
-        // Check if there's actual code between (not just blank lines or comments)
-        const linesBetween = lines.slice(lastImportLine, loc.line - 1);
-        const hasCode = linesBetween.some(l => {
-          const trimmed = l.trim();
-          return trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*");
-        });
-        if (hasCode) {
-          hasCodeBetweenImports = true;
-        }
-      }
-      lastImportLine = loc.line;
-      
-      imports.push({
-        source,
-        category,
-        line: loc.line,
-        isTypeOnly,
-        isSideEffect: node.specifiers.length === 0,
-        node,
-      });
-    },
-    
-    // Track require() calls
-    CallExpression(path) {
-      const node = path.node;
-      
-      if (t.isIdentifier(node.callee, { name: "require" }) &&
-          node.arguments.length > 0 &&
-          t.isStringLiteral(node.arguments[0])) {
-        
-        const loc = node.loc?.start;
-        if (!loc) return;
-        
-        requires.push({
-          source: node.arguments[0].value,
-          line: loc.line,
-        });
-      }
-    },
-    
-    // Track used identifiers
-    Identifier(path) {
-      // Skip if it's a declaration
-      if (path.isBindingIdentifier()) return;
-      
-      // Skip property names
-      if (path.parentPath.isMemberExpression() && 
-          path.key === "property" && 
-          !path.parentPath.node.computed) {
-        return;
-      }
-      
-      // Skip import specifiers
-      if (path.parentPath.isImportSpecifier() || 
-          path.parentPath.isImportDefaultSpecifier() ||
-          path.parentPath.isImportNamespaceSpecifier()) {
-        return;
-      }
-      
-      usedIdentifiers.add(path.node.name);
-    },
-    
-    // Track JSX usage
-    JSXIdentifier(path) {
-      if (path.parentPath.isJSXOpeningElement() || path.parentPath.isJSXClosingElement()) {
-        usedIdentifiers.add(path.node.name);
-      }
-    },
-  });
-  
-  // Check import order
-  let lastCategory = 0;
-  let lastSource = "";
-  let orderViolations = [];
-  
-  for (let i = 0; i < imports.length; i++) {
-    const imp = imports[i];
-    
-    // Check category order
-    if (imp.category < lastCategory) {
-      orderViolations.push({
-        line: imp.line,
-        source: imp.source,
-        expectedBefore: getCategoryName(lastCategory),
-        actualCategory: getCategoryName(imp.category),
-      });
-    } else if (imp.category === lastCategory) {
-      // Within same category, check alphabetical order (optional)
-      // Skip this for now as it's too strict
-    }
-    
-    lastCategory = imp.category;
-    lastSource = imp.source;
-  }
-  
-  // Report order violations (grouped)
-  if (orderViolations.length > 0) {
-    const firstViolation = orderViolations[0];
-    findings.push({
-      type: "import_order",
-      severity: "INFO",
-      category: "ImportOrder",
-      file: filePath,
-      line: firstViolation.line,
-      column: 0,
-      title: `Import order inconsistent (${orderViolations.length} issues)`,
-      message: `'${firstViolation.source}' (${firstViolation.actualCategory}) should come before ${firstViolation.expectedBefore} imports.`,
-      codeSnippet: snippetForLine(lines, firstViolation.line),
-      confidence: "low",
-      fixHint: "Order imports: built-in → external → internal → parent → sibling → index → styles",
-    });
-  }
-  
-  // Check for mixed import/require
-  if (imports.length > 0 && requires.length > 0) {
-    const firstRequire = requires[0];
-    findings.push({
-      type: "mixed_imports",
-      severity: "INFO",
-      category: "ImportOrder",
-      file: filePath,
-      line: firstRequire.line,
-      column: 0,
-      title: "Mixed import and require statements",
-      message: `File uses both ESM imports (${imports.length}) and CommonJS require (${requires.length}). Consider using consistent module syntax.`,
-      codeSnippet: snippetForLine(lines, firstRequire.line),
-      confidence: "low",
-      fixHint: "Convert to ESM: import x from 'y' instead of const x = require('y')",
-    });
-  }
-  
-  // Check for code between imports
-  if (hasCodeBetweenImports) {
-    findings.push({
-      type: "code_between_imports",
-      severity: "INFO",
-      category: "ImportOrder",
-      file: filePath,
-      line: 1,
-      column: 0,
-      title: "Code between import statements",
-      message: "There is code between import statements. Keep all imports at the top of the file.",
-      codeSnippet: "",
-      confidence: "med",
-      fixHint: "Move all imports to the top of the file, before any other code",
-    });
-  }
-  
-  // Check for side-effect imports (warn if not intentional)
-  const sideEffectImports = imports.filter(i => i.isSideEffect);
-  for (const imp of sideEffectImports) {
-    // Skip known side-effect imports
-    if (/\.(css|scss|sass|less)$/.test(imp.source)) continue;
-    if (imp.source.includes("polyfill")) continue;
-    if (imp.source.includes("register")) continue;
-    
-    findings.push({
-      type: "side_effect_import",
-      severity: "INFO",
-      category: "ImportOrder",
-      file: filePath,
-      line: imp.line,
-      column: 0,
-      title: `Side-effect import: ${imp.source}`,
-      message: "Import doesn't import any values. If intentional, add a comment.",
-      codeSnippet: snippetForLine(lines, imp.line),
-      confidence: "low",
-      fixHint: "Add // side-effect import comment or import specific values",
-    });
-  }
-  
-  // Check for potentially unused imports
-  const unusedImports = [];
-  for (const identifier of importedIdentifiers) {
-    if (!usedIdentifiers.has(identifier)) {
-      // Skip common false positives
-      if (identifier === "React") continue; // JSX transform
-      if (identifier.startsWith("_")) continue; // Intentionally unused
-      
-      unusedImports.push(identifier);
-    }
-  }
-  
-  if (unusedImports.length > 0) {
-    // Find the line for the first unused import
-    let unusedLine = 1;
-    for (const imp of imports) {
-      for (const spec of imp.node.specifiers) {
-        if (unusedImports.includes(spec.local.name)) {
-          unusedLine = imp.line;
-          break;
-        }
-      }
-    }
-    
-    findings.push({
-      type: "unused_import",
-      severity: "INFO",
-      category: "ImportOrder",
-      file: filePath,
-      line: unusedLine,
-      column: 0,
-      title: `Potentially unused imports (${unusedImports.length})`,
-      message: `Imports may be unused: ${unusedImports.slice(0, 5).join(", ")}${unusedImports.length > 5 ? "..." : ""}`,
-      codeSnippet: snippetForLine(lines, unusedLine),
-      confidence: "low",
-      fixHint: "Remove unused imports or prefix with underscore if intentional",
-    });
-  }
-  
-  // Check for imports that should use 'import type'
-  traverse(ast, {
-    ImportDeclaration(path) {
-      const node = path.node;
-      if (node.importKind === "type") return; // Already type import
-      
-      const loc = node.loc?.start;
-      if (!loc) return;
-      
-      // Check if all specifiers are only used as types
-      let allTypeOnly = true;
-      
-      for (const specifier of node.specifiers) {
-        if (!t.isImportSpecifier(specifier)) {
-          allTypeOnly = false;
-          break;
-        }
-        
-        const name = specifier.local.name;
-        
-        // Check if used as value anywhere
-        let usedAsValue = false;
-        traverse(ast, {
-          Identifier(innerPath) {
-            if (innerPath.node.name !== name) return;
-            if (innerPath.parentPath.isImportSpecifier()) return;
-            
-            // Check if in type annotation
-            if (innerPath.findParent(p => 
-              p.isTSTypeAnnotation() || 
-              p.isTSTypeReference() ||
-              p.isTSInterfaceDeclaration() ||
-              p.isTSTypeAliasDeclaration()
-            )) {
-              return; // Type usage, OK
-            }
-            
-            usedAsValue = true;
-          },
-        }, path.scope, path);
-        
-        if (usedAsValue) {
-          allTypeOnly = false;
-          break;
-        }
-      }
-      
-      if (allTypeOnly && node.specifiers.length > 0) {
-        findings.push({
-          type: "should_be_type_import",
-          severity: "INFO",
-          category: "ImportOrder",
-          file: filePath,
-          line: loc.line,
-          column: 0,
-          title: "Import could use 'import type'",
-          message: "All imports from this module are only used as types.",
-          codeSnippet: snippetForLine(lines, loc.line),
-          confidence: "low",
-          fixHint: "Change to: import type { ... } from '...'",
-        });
-      }
-    },
-  });
-  
-  return findings;
-}
-
-module.exports = {
-  analyzeImportOrder,
-  getImportCategory,
-  getCategoryName,
-  IMPORT_CATEGORIES,
-  BUILTIN_MODULES,
-};