@vibecheckai/cli 3.3.0 → 3.5.0

package/bin/runners/lib/polish/autofix/dead-code.js

@@ -0,0 +1,280 @@
+/**
+ * Dead Code Removal - Auto-fix Polish Pass
+ * 
+ * Removes:
+ * - Unused imports
+ * - Unreachable code after return/throw/break/continue
+ * - Unused variables (optional, disabled by default)
+ * 
+ * Uses Babel AST analysis to detect and remove dead code safely.
+ */
+
+"use strict";
+
+const { parse } = require("@babel/parser");
+const traverse = require("@babel/traverse").default || require("@babel/traverse");
+const generate = require("@babel/generator").default || require("@babel/generator");
+const fs = require("fs");
+const path = require("path");
+const { findAllFilesSync, readFileSafeSync } = require("../utils");
+
+/**
+ * Parse code into AST
+ */
+function parseCode(code, filePath) {
+  const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+  const plugins = ["decorators-legacy", "classProperties", "classPrivateProperties"];
+
+  if (isTypeScript) plugins.push("typescript");
+  plugins.push("jsx");
+
+  return parse(code, {
+    sourceType: "module",
+    plugins,
+    errorRecovery: true,
+  });
+}
+
+/**
+ * Collect all identifier usages in the file (excluding declarations)
+ */
+function collectUsages(ast) {
+  const usages = new Set();
+
+  traverse(ast, {
+    Identifier(nodePath) {
+      // Skip declarations
+      if (nodePath.isBindingIdentifier()) return;
+
+      // Skip property names
+      if (
+        nodePath.parent.type === "MemberExpression" &&
+        nodePath.parent.property === nodePath.node &&
+        !nodePath.parent.computed
+      ) {
+        return;
+      }
+
+      // Skip object keys
+      if (
+        nodePath.parent.type === "ObjectProperty" &&
+        nodePath.parent.key === nodePath.node &&
+        !nodePath.parent.computed
+      ) {
+        return;
+      }
+
+      usages.add(nodePath.node.name);
+    },
+
+    // JSX also counts as usage
+    JSXIdentifier(nodePath) {
+      usages.add(nodePath.node.name);
+    },
+  });
+
+  return usages;
+}
+
+/**
+ * Process a single file for dead code
+ */
+function processFile(filePath, options = {}) {
+  const { dryRun = true, removeUnusedVars = false } = options;
+  const changes = [];
+
+  const code = readFileSafeSync(filePath);
+  if (!code) return { changes: [], modified: false };
+
+  // Quick check - skip files without imports
+  if (!code.includes("import ")) {
+    return { changes: [], modified: false };
+  }
+
+  let ast;
+  try {
+    ast = parseCode(code, filePath);
+  } catch (err) {
+    return { changes: [], modified: false, error: `Parse error: ${err.message}` };
+  }
+
+  const relativePath = path.relative(process.cwd(), filePath);
+
+  // Collect all identifier usages
+  const usages = collectUsages(ast);
+
+  let modified = false;
+  const importsToRemove = [];
+
+  // First pass: identify unused imports
+  traverse(ast, {
+    ImportDeclaration(nodePath) {
+      const { node } = nodePath;
+      const specifiers = node.specifiers;
+
+      // Track which specifiers are unused
+      const unusedSpecifiers = [];
+      const usedSpecifiers = [];
+
+      for (const spec of specifiers) {
+        let localName;
+
+        if (spec.type === "ImportDefaultSpecifier") {
+          localName = spec.local.name;
+        } else if (spec.type === "ImportSpecifier") {
+          localName = spec.local.name;
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          localName = spec.local.name;
+        }
+
+        if (localName && !usages.has(localName)) {
+          // Check if it's a type-only import (TypeScript)
+          const isTypeOnly = spec.importKind === "type" || node.importKind === "type";
+
+          unusedSpecifiers.push({
+            name: localName,
+            spec,
+            isTypeOnly,
+          });
+        } else {
+          usedSpecifiers.push(spec);
+        }
+      }
+
+      // Handle unused imports
+      if (unusedSpecifiers.length > 0) {
+        const line = node.loc?.start?.line || "?";
+
+        for (const unused of unusedSpecifiers) {
+          changes.push({
+            file: relativePath,
+            line,
+            type: "unused-import",
+            detail: `Unused import: '${unused.name}' from '${node.source.value}'`,
+            isTypeOnly: unused.isTypeOnly,
+          });
+        }
+
+        if (usedSpecifiers.length === 0) {
+          // Remove entire import declaration
+          importsToRemove.push(nodePath);
+        } else if (usedSpecifiers.length < specifiers.length) {
+          // Remove only unused specifiers
+          node.specifiers = usedSpecifiers;
+          modified = true;
+        }
+      }
+    },
+  });
+
+  // Remove unused import declarations
+  for (const importPath of importsToRemove) {
+    importPath.remove();
+    modified = true;
+  }
+
+  // Second pass: find unreachable code
+  traverse(ast, {
+    BlockStatement(nodePath) {
+      const { node } = nodePath;
+      const body = node.body;
+
+      let foundTerminator = false;
+      const unreachableStart = [];
+
+      for (let i = 0; i < body.length; i++) {
+        const stmt = body[i];
+
+        if (foundTerminator) {
+          // This statement is unreachable
+          const line = stmt.loc?.start?.line || "?";
+          changes.push({
+            file: relativePath,
+            line,
+            type: "unreachable-code",
+            detail: "Unreachable code after return/throw/break/continue",
+          });
+          unreachableStart.push(i);
+        }
+
+        // Check if this statement terminates the block
+        if (
+          stmt.type === "ReturnStatement" ||
+          stmt.type === "ThrowStatement" ||
+          stmt.type === "BreakStatement" ||
+          stmt.type === "ContinueStatement"
+        ) {
+          foundTerminator = true;
+        }
+      }
+
+      // Remove unreachable statements (in reverse to preserve indices)
+      if (unreachableStart.length > 0 && !dryRun) {
+        for (let i = unreachableStart.length - 1; i >= 0; i--) {
+          body.splice(unreachableStart[i], 1);
+        }
+        modified = true;
+      }
+    },
+  });
+
+  // Write changes
+  if (modified && !dryRun) {
+    try {
+      const output = generate(ast, { retainLines: true }, code);
+      fs.writeFileSync(filePath, output.code, "utf8");
+    } catch (err) {
+      return { changes, modified: false, error: `Generate error: ${err.message}` };
+    }
+  }
+
+  return { changes, modified };
+}
+
+/**
+ * Remove dead code from all files
+ */
+async function removeDeadCode(targetPath, options = {}) {
+  const { dryRun = true, removeUnusedVars = false } = options;
+
+  const pattern = /\.(js|jsx|ts|tsx|mjs)$/;
+  const files = findAllFilesSync(targetPath, pattern);
+
+  const allChanges = [];
+  const modifiedFiles = [];
+  const errors = [];
+
+  for (const file of files) {
+    const result = processFile(file, { dryRun, removeUnusedVars });
+
+    if (result.error) {
+      errors.push({ file, error: result.error });
+    }
+
+    if (result.changes.length > 0) {
+      allChanges.push(...result.changes);
+    }
+
+    if (result.modified) {
+      modifiedFiles.push(path.relative(process.cwd(), file));
+    }
+  }
+
+  return {
+    changes: allChanges,
+    files: modifiedFiles,
+    errors,
+    summary: {
+      filesScanned: files.length,
+      filesModified: modifiedFiles.length,
+      unusedImports: allChanges.filter((c) => c.type === "unused-import").length,
+      unreachableCode: allChanges.filter((c) => c.type === "unreachable-code").length,
+    },
+  };
+}
+
+module.exports = {
+  removeDeadCode,
+  processFile,
+  collectUsages,
+};

package/bin/runners/lib/polish/autofix/imports-optimizer.js

@@ -0,0 +1,344 @@
+/**
+ * Import Optimizer - Auto-fix Polish Pass
+ * 
+ * Optimizes imports:
+ * - Sorts imports alphabetically
+ * - Groups imports by type (builtin, external, internal)
+ * - Deduplicates imports from same source
+ * - Removes duplicate specifiers
+ * 
+ * Uses Babel AST for safe transformations.
+ */
+
+"use strict";
+
+const { parse } = require("@babel/parser");
+const traverse = require("@babel/traverse").default || require("@babel/traverse");
+const generate = require("@babel/generator").default || require("@babel/generator");
+const t = require("@babel/types");
+const fs = require("fs");
+const path = require("path");
+const { findAllFilesSync, readFileSafeSync } = require("../utils");
+
+// Built-in Node.js 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",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "timers",
+  "tls",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "zlib",
+]);
+
+/**
+ * Get import group for sorting
+ */
+function getImportGroup(source) {
+  // Node builtin
+  if (BUILTIN_MODULES.has(source) || source.startsWith("node:")) {
+    return 0;
+  }
+
+  // React/Next special handling
+  if (source === "react" || source === "react-dom" || source === "next") {
+    return 1;
+  }
+
+  // External packages (node_modules)
+  if (!source.startsWith(".") && !source.startsWith("@/") && !source.startsWith("~/")) {
+    return 2;
+  }
+
+  // Internal aliases (@/, ~/)
+  if (source.startsWith("@/") || source.startsWith("~/")) {
+    return 3;
+  }
+
+  // Relative imports
+  return 4;
+}
+
+/**
+ * Parse code into AST
+ */
+function parseCode(code, filePath) {
+  const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+  const plugins = ["decorators-legacy", "classProperties"];
+
+  if (isTypeScript) plugins.push("typescript");
+  plugins.push("jsx");
+
+  return parse(code, {
+    sourceType: "module",
+    plugins,
+    errorRecovery: true,
+  });
+}
+
+/**
+ * Sort import specifiers alphabetically
+ */
+function sortSpecifiers(specifiers) {
+  // Separate default from named
+  const defaultSpec = specifiers.find((s) => s.type === "ImportDefaultSpecifier");
+  const namespaceSpec = specifiers.find((s) => s.type === "ImportNamespaceSpecifier");
+  const namedSpecs = specifiers
+    .filter((s) => s.type === "ImportSpecifier")
+    .sort((a, b) => {
+      const nameA = a.imported?.name || a.local.name;
+      const nameB = b.imported?.name || b.local.name;
+      return nameA.localeCompare(nameB);
+    });
+
+  // Reconstruct: default, namespace, then named
+  const result = [];
+  if (defaultSpec) result.push(defaultSpec);
+  if (namespaceSpec) result.push(namespaceSpec);
+  result.push(...namedSpecs);
+
+  return result;
+}
+
+/**
+ * Deduplicate specifiers (remove duplicate imports from same source)
+ */
+function dedupeSpecifiers(specifiers) {
+  const seen = new Set();
+  return specifiers.filter((spec) => {
+    const key =
+      spec.type === "ImportDefaultSpecifier"
+        ? "default"
+        : spec.type === "ImportNamespaceSpecifier"
+        ? "namespace"
+        : spec.imported?.name || spec.local.name;
+
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+/**
+ * Process a single file
+ */
+function processFile(filePath, options = {}) {
+  const { dryRun = true, sortOnly = false } = options;
+  const changes = [];
+
+  const code = readFileSafeSync(filePath);
+  if (!code) return { changes: [], modified: false };
+
+  // Quick check
+  if (!code.includes("import ")) {
+    return { changes: [], modified: false };
+  }
+
+  let ast;
+  try {
+    ast = parseCode(code, filePath);
+  } catch (err) {
+    return { changes: [], modified: false, error: `Parse error: ${err.message}` };
+  }
+
+  const relativePath = path.relative(process.cwd(), filePath);
+
+  // Collect all imports
+  const imports = [];
+  let firstImportIndex = -1;
+  let lastImportIndex = -1;
+
+  traverse(ast, {
+    ImportDeclaration(nodePath) {
+      const idx = ast.program.body.indexOf(nodePath.node);
+      if (firstImportIndex === -1) firstImportIndex = idx;
+      lastImportIndex = idx;
+
+      imports.push({
+        node: nodePath.node,
+        source: nodePath.node.source.value,
+        group: getImportGroup(nodePath.node.source.value),
+        path: nodePath,
+      });
+    },
+  });
+
+  if (imports.length <= 1) {
+    return { changes: [], modified: false };
+  }
+
+  // Merge imports from same source
+  const mergedImports = new Map();
+  let hasDuplicateSources = false;
+
+  for (const imp of imports) {
+    if (mergedImports.has(imp.source)) {
+      hasDuplicateSources = true;
+      const existing = mergedImports.get(imp.source);
+      // Merge specifiers
+      existing.node.specifiers.push(...imp.node.specifiers);
+    } else {
+      mergedImports.set(imp.source, imp);
+    }
+  }
+
+  // Check if imports are already sorted
+  const sortedImports = Array.from(mergedImports.values()).sort((a, b) => {
+    // First by group
+    if (a.group !== b.group) return a.group - b.group;
+    // Then alphabetically
+    return a.source.localeCompare(b.source);
+  });
+
+  // Check if reordering is needed
+  const currentOrder = imports.map((i) => i.source);
+  const newOrder = sortedImports.map((i) => i.source);
+  const needsReorder = JSON.stringify(currentOrder) !== JSON.stringify(newOrder);
+
+  // Dedupe and sort specifiers within each import
+  let specifiersChanged = false;
+  for (const imp of sortedImports) {
+    const originalCount = imp.node.specifiers.length;
+    const deduped = dedupeSpecifiers(imp.node.specifiers);
+    const sorted = sortSpecifiers(deduped);
+
+    if (sorted.length !== originalCount) {
+      specifiersChanged = true;
+      changes.push({
+        file: relativePath,
+        line: imp.node.loc?.start?.line || "?",
+        type: "duplicate-specifier",
+        detail: `Removed duplicate specifiers from '${imp.source}'`,
+      });
+    }
+
+    imp.node.specifiers = sorted;
+  }
+
+  if (hasDuplicateSources) {
+    changes.push({
+      file: relativePath,
+      line: "multiple",
+      type: "duplicate-import",
+      detail: "Merged duplicate imports from same source",
+    });
+  }
+
+  if (needsReorder) {
+    changes.push({
+      file: relativePath,
+      line: "multiple",
+      type: "import-order",
+      detail: "Sorted imports by group and alphabetically",
+    });
+  }
+
+  const modified = needsReorder || hasDuplicateSources || specifiersChanged;
+
+  if (modified && !dryRun) {
+    // Remove old imports and insert sorted ones
+    const otherStatements = ast.program.body.filter(
+      (node) => node.type !== "ImportDeclaration"
+    );
+
+    // Add blank line between groups
+    const newImports = [];
+    let lastGroup = -1;
+
+    for (const imp of sortedImports) {
+      if (lastGroup !== -1 && imp.group !== lastGroup) {
+        // Add blank line (handled by generator with comments)
+      }
+      newImports.push(imp.node);
+      lastGroup = imp.group;
+    }
+
+    ast.program.body = [...newImports, ...otherStatements];
+
+    try {
+      const output = generate(ast, { retainLines: false }, code);
+      fs.writeFileSync(filePath, output.code, "utf8");
+    } catch (err) {
+      return { changes, modified: false, error: `Generate error: ${err.message}` };
+    }
+  }
+
+  return { changes, modified };
+}
+
+/**
+ * Optimize imports in all files
+ */
+async function optimizeImports(targetPath, options = {}) {
+  const { dryRun = true, sortOnly = false } = options;
+
+  const pattern = /\.(js|jsx|ts|tsx|mjs)$/;
+  const files = findAllFilesSync(targetPath, pattern);
+
+  const allChanges = [];
+  const modifiedFiles = [];
+  const errors = [];
+
+  for (const file of files) {
+    const result = processFile(file, { dryRun, sortOnly });
+
+    if (result.error) {
+      errors.push({ file, error: result.error });
+    }
+
+    if (result.changes.length > 0) {
+      allChanges.push(...result.changes);
+    }
+
+    if (result.modified) {
+      modifiedFiles.push(path.relative(process.cwd(), file));
+    }
+  }
+
+  return {
+    changes: allChanges,
+    files: modifiedFiles,
+    errors,
+    summary: {
+      filesScanned: files.length,
+      filesModified: modifiedFiles.length,
+      duplicateImports: allChanges.filter((c) => c.type === "duplicate-import").length,
+      reordered: allChanges.filter((c) => c.type === "import-order").length,
+    },
+  };
+}
+
+module.exports = {
+  optimizeImports,
+  processFile,
+  getImportGroup,
+  sortSpecifiers,
+};