@vibecheckai/cli 3.5.0 → 3.5.2

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

@@ -1,280 +0,0 @@
-/**
- * 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

@@ -1,344 +0,0 @@
-/**
- * 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,
-};