@vibecheckai/cli 3.5.0 → 3.5.2

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

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

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

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