@vibecheckai/cli 3.3.0 → 3.5.0

package/bin/runners/lib/polish/autofix/index.js

@@ -0,0 +1,200 @@
+/**
+ * Polish Auto-Fix Passes
+ * 
+ * Collection of automated code fixes for production readiness.
+ * Each pass transforms code using Babel AST without requiring an LLM.
+ * 
+ * Usage:
+ *   vibecheck polish              # Dry-run (show what would change)
+ *   vibecheck polish --apply      # Apply changes
+ *   vibecheck polish --passes remove-consoles,dead-code
+ */
+
+"use strict";
+
+const { removeConsoles } = require("./remove-consoles");
+const { strengthenTypes } = require("./strengthen-types");
+const { wrapAsyncHandlers } = require("./async-handlers");
+const { removeDeadCode } = require("./dead-code");
+const { fixAccessibility } = require("./accessibility-fixes");
+const { optimizeImports } = require("./imports-optimizer");
+
+/**
+ * All available polish passes
+ * Order matters - some passes should run before others
+ */
+const POLISH_PASSES = [
+  {
+    id: "remove-consoles",
+    name: "Remove console statements",
+    description: "Remove console.log/debug/info (keep error/warn)",
+    fn: removeConsoles,
+    category: "cleanup",
+    safe: true, // Safe to auto-apply
+  },
+  {
+    id: "dead-code",
+    name: "Remove dead code",
+    description: "Remove unused imports and unreachable code",
+    fn: removeDeadCode,
+    category: "cleanup",
+    safe: true,
+  },
+  {
+    id: "optimize-imports",
+    name: "Optimize imports",
+    description: "Sort, dedupe, and organize imports",
+    fn: optimizeImports,
+    category: "style",
+    safe: true,
+  },
+  {
+    id: "strengthen-types",
+    name: "Strengthen types",
+    description: "Replace `any` with inferred types where possible",
+    fn: strengthenTypes,
+    category: "types",
+    safe: false, // Review recommended
+  },
+  {
+    id: "async-handlers",
+    name: "Wrap async handlers",
+    description: "Add try-catch to unhandled async functions",
+    fn: wrapAsyncHandlers,
+    category: "error-handling",
+    safe: false, // Review recommended
+  },
+  {
+    id: "accessibility",
+    name: "Fix accessibility",
+    description: "Add missing alt, aria-label, and role attributes",
+    fn: fixAccessibility,
+    category: "accessibility",
+    safe: false, // Review recommended - may add empty placeholders
+  },
+];
+
+/**
+ * Get all available passes
+ */
+function getAvailablePasses() {
+  return POLISH_PASSES.map(({ id, name, description, category, safe }) => ({
+    id,
+    name,
+    description,
+    category,
+    safe,
+  }));
+}
+
+/**
+ * Get passes by category
+ */
+function getPassesByCategory(category) {
+  return POLISH_PASSES.filter((p) => p.category === category);
+}
+
+/**
+ * Get safe passes only (can be auto-applied)
+ */
+function getSafePasses() {
+  return POLISH_PASSES.filter((p) => p.safe);
+}
+
+/**
+ * Run specified polish passes
+ * 
+ * @param {string} targetPath - Directory to process
+ * @param {Object} options
+ * @param {boolean} options.dryRun - If true, don't modify files
+ * @param {string[]} options.passes - Pass IDs to run (default: all)
+ * @param {boolean} options.safeOnly - Only run safe passes
+ * @returns {Object} Results from all passes
+ */
+async function runPolishPasses(targetPath, options = {}) {
+  const {
+    dryRun = true,
+    passes = null,
+    safeOnly = false,
+    verbose = false,
+  } = options;
+
+  // Determine which passes to run
+  let passesToRun = POLISH_PASSES;
+
+  if (safeOnly) {
+    passesToRun = passesToRun.filter((p) => p.safe);
+  }
+
+  if (passes && passes.length > 0) {
+    passesToRun = passesToRun.filter((p) => passes.includes(p.id));
+  }
+
+  const results = {
+    passes: [],
+    totalChanges: 0,
+    totalFilesModified: new Set(),
+    errors: [],
+    dryRun,
+  };
+
+  for (const pass of passesToRun) {
+    const startTime = Date.now();
+
+    try {
+      const passResult = await pass.fn(targetPath, { dryRun });
+
+      results.passes.push({
+        id: pass.id,
+        name: pass.name,
+        changes: passResult.changes.length,
+        files: passResult.files,
+        errors: passResult.errors || [],
+        duration: Date.now() - startTime,
+        summary: passResult.summary,
+      });
+
+      results.totalChanges += passResult.changes.length;
+      passResult.files.forEach((f) => results.totalFilesModified.add(f));
+
+      if (passResult.errors?.length > 0) {
+        results.errors.push(...passResult.errors.map((e) => ({ pass: pass.id, ...e })));
+      }
+    } catch (err) {
+      results.passes.push({
+        id: pass.id,
+        name: pass.name,
+        changes: 0,
+        files: [],
+        errors: [{ error: err.message }],
+        duration: Date.now() - startTime,
+        failed: true,
+      });
+
+      results.errors.push({
+        pass: pass.id,
+        error: err.message,
+      });
+    }
+  }
+
+  // Convert Set to Array
+  results.totalFilesModified = Array.from(results.totalFilesModified);
+
+  return results;
+}
+
+module.exports = {
+  POLISH_PASSES,
+  runPolishPasses,
+  getAvailablePasses,
+  getPassesByCategory,
+  getSafePasses,
+  // Individual passes
+  removeConsoles,
+  strengthenTypes,
+  wrapAsyncHandlers,
+  removeDeadCode,
+  fixAccessibility,
+  optimizeImports,
+};

package/bin/runners/lib/polish/autofix/remove-consoles.js

@@ -0,0 +1,209 @@
+/**
+ * Remove Console Statements - Auto-fix Polish Pass
+ * 
+ * Removes console.log, console.debug, console.info, console.trace
+ * Preserves console.error, console.warn (these are intentional)
+ * 
+ * Uses Babel AST transformation for safe, accurate modifications.
+ */
+
+"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");
+
+// Console methods to REMOVE (development/debug)
+const REMOVE_METHODS = new Set([
+  "log",
+  "debug",
+  "info",
+  "trace",
+  "dir",
+  "dirxml",
+  "table",
+  "count",
+  "countReset",
+  "group",
+  "groupCollapsed",
+  "groupEnd",
+  "time",
+  "timeEnd",
+  "timeLog",
+  "timeStamp",
+  "profile",
+  "profileEnd",
+  "clear",
+]);
+
+// Console methods to KEEP (production-appropriate)
+const KEEP_METHODS = new Set(["error", "warn", "assert"]);
+
+/**
+ * Parse JavaScript/TypeScript code into AST
+ */
+function parseCode(code, filePath) {
+  const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+  const isJSX = filePath.endsWith(".jsx") || filePath.endsWith(".tsx");
+
+  const plugins = ["decorators-legacy", "classProperties", "classPrivateProperties", "classPrivateMethods"];
+
+  if (isTypeScript) {
+    plugins.push("typescript");
+  }
+  if (isJSX || isTypeScript) {
+    plugins.push("jsx");
+  }
+
+  return parse(code, {
+    sourceType: "module",
+    plugins,
+    errorRecovery: true, // Continue parsing even with errors
+  });
+}
+
+/**
+ * Remove console statements from a single file
+ * @param {string} filePath - Path to file
+ * @param {Object} options - { dryRun: boolean }
+ * @returns {Object} - { changes: Array, modified: boolean }
+ */
+function processFile(filePath, options = {}) {
+  const { dryRun = true } = options;
+  const changes = [];
+
+  const code = readFileSafeSync(filePath);
+  if (!code) return { changes: [], modified: false };
+
+  // Skip if file doesn't contain console
+  if (!code.includes("console.")) {
+    return { changes: [], modified: false };
+  }
+
+  let ast;
+  try {
+    ast = parseCode(code, filePath);
+  } catch (err) {
+    // Can't parse, skip file
+    return { changes: [], modified: false, error: `Parse error: ${err.message}` };
+  }
+
+  let modified = false;
+  const relativePath = path.relative(process.cwd(), filePath);
+
+  traverse(ast, {
+    CallExpression(nodePath) {
+      const { node } = nodePath;
+
+      // Check for console.method() pattern
+      if (
+        node.callee.type === "MemberExpression" &&
+        node.callee.object.type === "Identifier" &&
+        node.callee.object.name === "console" &&
+        node.callee.property.type === "Identifier"
+      ) {
+        const method = node.callee.property.name;
+
+        // Should we remove this method?
+        if (REMOVE_METHODS.has(method)) {
+          const line = node.loc?.start?.line || "?";
+          const column = node.loc?.start?.column || "?";
+
+          changes.push({
+            file: relativePath,
+            line,
+            column,
+            type: "remove-console",
+            detail: `console.${method}`,
+            code: code.substring(node.start, Math.min(node.end, node.start + 60)),
+          });
+
+          // Remove the entire expression statement
+          if (nodePath.parentPath.type === "ExpressionStatement") {
+            nodePath.parentPath.remove();
+          } else {
+            // If it's used as a value (rare), replace with undefined
+            nodePath.replaceWith({ type: "Identifier", name: "undefined" });
+          }
+
+          modified = true;
+        }
+      }
+    },
+  });
+
+  // Write changes if not dry run and file was modified
+  if (modified && !dryRun) {
+    try {
+      const output = generate(
+        ast,
+        {
+          retainLines: true,
+          compact: false,
+          concise: false,
+        },
+        code
+      );
+      fs.writeFileSync(filePath, output.code, "utf8");
+    } catch (err) {
+      return { changes, modified: false, error: `Generate error: ${err.message}` };
+    }
+  }
+
+  return { changes, modified };
+}
+
+/**
+ * Remove console statements from all files in a directory
+ * @param {string} targetPath - Directory to process
+ * @param {Object} options - { dryRun: boolean }
+ * @returns {Object} - { changes: Array, files: Array }
+ */
+async function removeConsoles(targetPath, options = {}) {
+  const { dryRun = true } = options;
+
+  // Find all JavaScript/TypeScript files
+  const pattern = /\.(js|jsx|ts|tsx|mjs|cjs)$/;
+  const files = findAllFilesSync(targetPath, pattern);
+
+  const allChanges = [];
+  const modifiedFiles = [];
+  const errors = [];
+
+  for (const file of files) {
+    const result = processFile(file, { dryRun });
+
+    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,
+      statementsRemoved: allChanges.length,
+    },
+  };
+}
+
+module.exports = {
+  removeConsoles,
+  processFile,
+  REMOVE_METHODS,
+  KEEP_METHODS,
+};

package/bin/runners/lib/polish/autofix/strengthen-types.js

@@ -0,0 +1,245 @@
+/**
+ * Strengthen Types - Auto-fix Polish Pass
+ * 
+ * Replaces `any` types with more specific types where inferrable:
+ * - Function parameters with usage patterns
+ * - Return types from return statements
+ * - Variable declarations with assignments
+ * 
+ * Uses Babel AST transformation with TypeScript plugin.
+ */
+
+"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");
+
+/**
+ * Infer type from a value expression
+ */
+function inferTypeFromValue(node) {
+  if (!node) return null;
+
+  switch (node.type) {
+    case "StringLiteral":
+    case "TemplateLiteral":
+      return t.tsStringKeyword();
+
+    case "NumericLiteral":
+      return t.tsNumberKeyword();
+
+    case "BooleanLiteral":
+      return t.tsBooleanKeyword();
+
+    case "NullLiteral":
+      return t.tsNullKeyword();
+
+    case "ArrayExpression":
+      if (node.elements.length > 0) {
+        const elementType = inferTypeFromValue(node.elements[0]);
+        if (elementType) {
+          return t.tsArrayType(elementType);
+        }
+      }
+      return t.tsArrayType(t.tsUnknownKeyword());
+
+    case "ObjectExpression":
+      return t.tsTypeLiteral([]);
+
+    case "ArrowFunctionExpression":
+    case "FunctionExpression":
+      return t.tsFunctionType(null, [], t.tsVoidKeyword());
+
+    case "CallExpression":
+      // Common patterns
+      if (node.callee.type === "Identifier") {
+        if (node.callee.name === "Promise") {
+          return t.tsTypeReference(t.identifier("Promise"), t.tsTypeParameterInstantiation([t.tsUnknownKeyword()]));
+        }
+      }
+      return null;
+
+    case "NewExpression":
+      if (node.callee.type === "Identifier") {
+        const typeName = node.callee.name;
+        if (["Date", "Map", "Set", "WeakMap", "WeakSet", "RegExp", "Error"].includes(typeName)) {
+          return t.tsTypeReference(t.identifier(typeName));
+        }
+      }
+      return null;
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * Parse TypeScript code into AST
+ */
+function parseCode(code, filePath) {
+  return parse(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx", "decorators-legacy", "classProperties"],
+    errorRecovery: true,
+  });
+}
+
+/**
+ * Process a single TypeScript file
+ */
+function processFile(filePath, options = {}) {
+  const { dryRun = true } = options;
+  const changes = [];
+
+  // Only process TypeScript files
+  if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+    return { changes: [], modified: false };
+  }
+
+  const code = readFileSafeSync(filePath);
+  if (!code) return { changes: [], modified: false };
+
+  // Quick check - does file contain 'any'
+  if (!code.includes(": any") && !code.includes(":any")) {
+    return { changes: [], modified: false };
+  }
+
+  let ast;
+  try {
+    ast = parseCode(code, filePath);
+  } catch (err) {
+    return { changes: [], modified: false, error: `Parse error: ${err.message}` };
+  }
+
+  let modified = false;
+  const relativePath = path.relative(process.cwd(), filePath);
+
+  traverse(ast, {
+    // Variable declarations: const x: any = "value" -> const x: string = "value"
+    VariableDeclarator(nodePath) {
+      const { node } = nodePath;
+
+      if (
+        node.id.type === "Identifier" &&
+        node.id.typeAnnotation?.typeAnnotation?.type === "TSAnyKeyword" &&
+        node.init
+      ) {
+        const inferredType = inferTypeFromValue(node.init);
+        if (inferredType) {
+          const line = node.loc?.start?.line || "?";
+          changes.push({
+            file: relativePath,
+            line,
+            type: "strengthen-type",
+            detail: `${node.id.name}: any -> inferred type`,
+            from: "any",
+            to: generate(inferredType).code,
+          });
+
+          node.id.typeAnnotation.typeAnnotation = inferredType;
+          modified = true;
+        }
+      }
+    },
+
+    // Function parameters: Replace (x: any) with (x: unknown) as safer default
+    TSAnyKeyword(nodePath) {
+      const parent = nodePath.parent;
+      const grandParent = nodePath.parentPath?.parent;
+
+      // Skip if it's in a type assertion or generic
+      if (parent.type === "TSTypeAssertion" || parent.type === "TSAsExpression") {
+        return;
+      }
+
+      // For parameters without clear inference, use `unknown` (safer than `any`)
+      if (
+        parent.type === "TSTypeAnnotation" &&
+        grandParent?.type === "Identifier" &&
+        nodePath.parentPath?.parentPath?.parent?.type === "FunctionDeclaration"
+      ) {
+        const line = nodePath.node.loc?.start?.line || "?";
+
+        // Only replace if it's a standalone `any` parameter
+        changes.push({
+          file: relativePath,
+          line,
+          type: "strengthen-type",
+          detail: `Parameter type: any -> unknown`,
+          suggestion: "Consider using a more specific type",
+          from: "any",
+          to: "unknown",
+        });
+
+        // Replace any with unknown (safer)
+        nodePath.replaceWith(t.tsUnknownKeyword());
+        modified = true;
+      }
+    },
+  });
+
+  // Write changes if not dry run
+  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 };
+}
+
+/**
+ * Strengthen types in all TypeScript files
+ */
+async function strengthenTypes(targetPath, options = {}) {
+  const { dryRun = true } = options;
+
+  // Only TypeScript files
+  const pattern = /\.(ts|tsx)$/;
+  const files = findAllFilesSync(targetPath, pattern);
+
+  const allChanges = [];
+  const modifiedFiles = [];
+  const errors = [];
+
+  for (const file of files) {
+    const result = processFile(file, { dryRun });
+
+    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,
+      typesStrengthened: allChanges.length,
+    },
+  };
+}
+
+module.exports = {
+  strengthenTypes,
+  processFile,
+  inferTypeFromValue,
+};