vibecheck-ai 2.0.1 → 5.0.0

package/bin/runners/lib/cleanup/engine.js

@@ -0,0 +1,571 @@
+/**
+ * vibecheck polish --cleanup Engine
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * CLEANUP ENGINE - Safe Code Transformations
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * Applies cleanup rules to files with:
+ * - Full diff preview before changes
+ * - Automatic backup for rollback
+ * - Risk assessment for each transformation
+ * - Support for regex and function-based pattern detection
+ * - File type filtering and exclusion patterns
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const {
+  SAFE_RULES,
+  MODERATE_RULES,
+  AGGRESSIVE_RULES,
+  CATEGORIES,
+  RISK_LEVELS,
+} = require("./rules");
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CONFIGURATION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * File extensions to scan by default
+ */
+const SCANNABLE_EXTENSIONS = new Set([
+  ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+  ".vue", ".svelte", ".astro",
+]);
+
+/**
+ * Directories to always skip
+ */
+const SKIP_DIRS = new Set([
+  "node_modules", ".git", "dist", "build", ".next", ".nuxt",
+  "coverage", ".vibecheck", ".cache", "__pycache__", ".turbo",
+  "out", ".output", ".vercel", ".netlify", ".amplify",
+]);
+
+/**
+ * Files to always skip (patterns)
+ */
+const SKIP_FILES = [
+  /\.min\.js$/,
+  /\.bundle\.js$/,
+  /\.d\.ts$/,
+  /\.map$/,
+  /package-lock\.json$/,
+  /yarn\.lock$/,
+  /pnpm-lock\.yaml$/,
+  /\.lock$/,
+];
+
+/**
+ * Maximum file size to scan (in bytes) - skip very large files
+ */
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// GLOB MATCHING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Simple glob pattern matching
+ * Supports: *, **, ?, [abc], [!abc]
+ */
+function matchGlob(pattern, filePath) {
+  // Normalize paths
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  
+  // Convert glob to regex
+  let regex = normalizedPattern
+    .replace(/\./g, "\\.")
+    .replace(/\*\*/g, "{{GLOBSTAR}}")
+    .replace(/\*/g, "[^/]*")
+    .replace(/\?/g, "[^/]")
+    .replace(/{{GLOBSTAR}}/g, ".*");
+  
+  // If pattern doesn't start with **, match anywhere
+  if (!normalizedPattern.startsWith("**/") && !normalizedPattern.startsWith("/")) {
+    regex = `(?:^|/)${regex}`;
+  }
+  
+  return new RegExp(regex + "$", "i").test(normalizedPath);
+}
+
+/**
+ * Check if file matches any exclusion pattern
+ */
+function isExcluded(filePath, excludePatterns = []) {
+  if (!excludePatterns || excludePatterns.length === 0) return false;
+  
+  for (const pattern of excludePatterns) {
+    if (matchGlob(pattern, filePath)) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FILE SCANNING
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Check if a file should be skipped
+ */
+function shouldSkipFile(filePath, fileName) {
+  // Check extension
+  const ext = path.extname(fileName).toLowerCase();
+  if (!SCANNABLE_EXTENSIONS.has(ext)) return true;
+  
+  // Check skip patterns
+  for (const pattern of SKIP_FILES) {
+    if (pattern.test(fileName)) return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Recursively find all scannable files with robust error handling
+ */
+async function findFiles(dir, opts = {}) {
+  const {
+    maxDepth = 10,
+    maxFiles = 5000,
+    exclude = [],
+  } = opts;
+  
+  const results = [];
+  const errors = [];
+  
+  async function walk(currentDir, depth) {
+    if (depth >= maxDepth) return;
+    if (results.length >= maxFiles) return;
+    
+    let entries;
+    try {
+      entries = await fs.promises.readdir(currentDir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code !== "ENOENT" && err.code !== "EACCES" && err.code !== "EPERM") {
+        errors.push({ path: currentDir, error: err.message });
+      }
+      return;
+    }
+    
+    for (const entry of entries) {
+      if (results.length >= maxFiles) break;
+      
+      // Skip hidden files/dirs (except .cursorrules, etc.)
+      if (entry.name.startsWith(".") && !entry.name.startsWith(".cursor")) continue;
+      
+      const fullPath = path.join(currentDir, entry.name);
+      
+      // Check exclusion patterns
+      if (isExcluded(fullPath, exclude)) continue;
+      
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name)) continue;
+        await walk(fullPath, depth + 1);
+      } else if (entry.isFile()) {
+        if (shouldSkipFile(fullPath, entry.name)) continue;
+        
+        // Check file size
+        try {
+          const stat = await fs.promises.stat(fullPath);
+          if (stat.size > MAX_FILE_SIZE) continue;
+        } catch {
+          continue;
+        }
+        
+        results.push(fullPath);
+      }
+    }
+  }
+  
+  await walk(dir, 0);
+  
+  return {
+    files: results,
+    errors,
+    truncated: results.length >= maxFiles,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// FINDING DETECTION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Analyze a single file for cleanup findings
+ */
+function analyzeFile(filePath, content, rules) {
+  const findings = [];
+  const lines = content.split("\n");
+  
+  for (const [ruleId, rule] of Object.entries(rules)) {
+    if (!rule.pattern) continue;
+    
+    // Handle array of patterns
+    const patterns = Array.isArray(rule.patterns) ? rule.patterns : [rule.pattern];
+    
+    for (const pattern of patterns) {
+      // Reset lastIndex for global patterns
+      if (pattern.global) {
+        pattern.lastIndex = 0;
+      }
+      
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        // Calculate line number
+        const beforeMatch = content.substring(0, match.index);
+        const lineNumber = beforeMatch.split("\n").length;
+        const lineContent = lines[lineNumber - 1] || "";
+        
+        findings.push({
+          ruleId,
+          rule,
+          file: filePath,
+          line: lineNumber,
+          column: match.index - beforeMatch.lastIndexOf("\n") - 1,
+          match: match[0],
+          lineContent: lineContent.trim(),
+          startIndex: match.index,
+          endIndex: match.index + match[0].length,
+        });
+        
+        // Prevent infinite loop for non-global patterns
+        if (!pattern.global) break;
+      }
+    }
+  }
+  
+  return findings;
+}
+
+/**
+ * Analyze entire project
+ */
+async function analyzeProject(projectPath, opts = {}) {
+  const {
+    aggressive = false,
+    includeModerate = true,
+    maxFiles = 1000,
+  } = opts;
+  
+  // Build rule set based on options
+  let rules = { ...SAFE_RULES };
+  if (includeModerate) {
+    rules = { ...rules, ...MODERATE_RULES };
+  }
+  if (aggressive) {
+    rules = { ...rules, ...AGGRESSIVE_RULES };
+  }
+  
+  const files = await findFiles(projectPath);
+  const limitedFiles = files.slice(0, maxFiles);
+  
+  const allFindings = [];
+  const fileResults = [];
+  
+  for (const filePath of limitedFiles) {
+    try {
+      const content = await fs.promises.readFile(filePath, "utf8");
+      const findings = analyzeFile(filePath, content, rules);
+      
+      if (findings.length > 0) {
+        fileResults.push({
+          file: filePath,
+          relativePath: path.relative(projectPath, filePath),
+          findingCount: findings.length,
+          findings,
+        });
+        allFindings.push(...findings);
+      }
+    } catch (err) {
+      // Skip files that can't be read
+    }
+  }
+  
+  // Group by risk level
+  const byRisk = {
+    safe: allFindings.filter(f => f.rule.riskLevel === "safe"),
+    moderate: allFindings.filter(f => f.rule.riskLevel === "moderate"),
+    aggressive: allFindings.filter(f => f.rule.riskLevel === "aggressive"),
+  };
+  
+  // Group by category
+  const byCategory = {};
+  for (const finding of allFindings) {
+    const cat = finding.rule.category;
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push(finding);
+  }
+  
+  return {
+    totalFiles: limitedFiles.length,
+    filesWithFindings: fileResults.length,
+    totalFindings: allFindings.length,
+    byRisk,
+    byCategory,
+    fileResults,
+    findings: allFindings,
+    truncated: files.length > maxFiles,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// TRANSFORMATION ENGINE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Calculate the diff for a single file
+ */
+function calculateFileDiff(content, findings) {
+  // Sort findings by position (reverse order for safe replacement)
+  const sortedFindings = [...findings].sort((a, b) => b.startIndex - a.startIndex);
+  
+  let newContent = content;
+  const changes = [];
+  
+  for (const finding of sortedFindings) {
+    if (!finding.rule.autoFixable) continue;
+    if (finding.rule.fix === null || finding.rule.fix === undefined) continue;
+    
+    const before = newContent.substring(
+      Math.max(0, finding.startIndex - 20),
+      finding.startIndex
+    );
+    const after = newContent.substring(
+      finding.endIndex,
+      Math.min(newContent.length, finding.endIndex + 20)
+    );
+    
+    changes.push({
+      ruleId: finding.ruleId,
+      line: finding.line,
+      removed: finding.match,
+      added: finding.rule.fix,
+      context: { before, after },
+    });
+    
+    // Apply the fix
+    newContent =
+      newContent.substring(0, finding.startIndex) +
+      finding.rule.fix +
+      newContent.substring(finding.endIndex);
+  }
+  
+  return {
+    originalContent: content,
+    newContent,
+    changes,
+    changed: newContent !== content,
+  };
+}
+
+/**
+ * Calculate diffs for all files
+ */
+async function calculateDiffs(projectPath, analysisResult, opts = {}) {
+  const { dryRun = true } = opts;
+  
+  const diffs = [];
+  
+  for (const fileResult of analysisResult.fileResults) {
+    try {
+      const content = await fs.promises.readFile(fileResult.file, "utf8");
+      const diff = calculateFileDiff(content, fileResult.findings);
+      
+      if (diff.changed) {
+        diffs.push({
+          file: fileResult.file,
+          relativePath: fileResult.relativePath,
+          ...diff,
+        });
+      }
+    } catch (err) {
+      // Skip files that can't be processed
+    }
+  }
+  
+  return {
+    filesChanged: diffs.length,
+    totalChanges: diffs.reduce((sum, d) => sum + d.changes.length, 0),
+    diffs,
+  };
+}
+
+/**
+ * Apply transformations to files
+ */
+async function applyTransformations(projectPath, diffs, backupDir) {
+  const applied = [];
+  const failed = [];
+  
+  // Create backup manifest
+  const backupManifest = {
+    timestamp: new Date().toISOString(),
+    projectPath,
+    files: [],
+  };
+  
+  // Backup and transform each file
+  for (const diff of diffs) {
+    try {
+      // Backup original
+      const backupPath = path.join(backupDir, diff.relativePath);
+      await fs.promises.mkdir(path.dirname(backupPath), { recursive: true });
+      await fs.promises.writeFile(backupPath, diff.originalContent, "utf8");
+      
+      backupManifest.files.push({
+        original: diff.file,
+        backup: backupPath,
+        relativePath: diff.relativePath,
+      });
+      
+      // Apply transformation
+      await fs.promises.writeFile(diff.file, diff.newContent, "utf8");
+      
+      applied.push({
+        file: diff.file,
+        relativePath: diff.relativePath,
+        changes: diff.changes.length,
+      });
+    } catch (err) {
+      failed.push({
+        file: diff.file,
+        error: err.message,
+      });
+    }
+  }
+  
+  // Save backup manifest
+  await fs.promises.writeFile(
+    path.join(backupDir, "_manifest.json"),
+    JSON.stringify(backupManifest, null, 2),
+    "utf8"
+  );
+  
+  return {
+    applied,
+    failed,
+    backupDir,
+    backupManifest,
+  };
+}
+
+/**
+ * Rollback transformations using backup
+ */
+async function rollbackTransformations(backupDir) {
+  const manifestPath = path.join(backupDir, "_manifest.json");
+  
+  if (!fs.existsSync(manifestPath)) {
+    return { success: false, error: "Backup manifest not found" };
+  }
+  
+  const manifest = JSON.parse(await fs.promises.readFile(manifestPath, "utf8"));
+  const restored = [];
+  const failed = [];
+  
+  for (const file of manifest.files) {
+    try {
+      const backupContent = await fs.promises.readFile(file.backup, "utf8");
+      await fs.promises.writeFile(file.original, backupContent, "utf8");
+      restored.push(file.original);
+    } catch (err) {
+      failed.push({ file: file.original, error: err.message });
+    }
+  }
+  
+  return {
+    success: failed.length === 0,
+    restored,
+    failed,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// RISK ASSESSMENT
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate risk assessment for transformations
+ */
+function assessRisk(analysisResult, diffsResult) {
+  const risks = [];
+  
+  // Count by risk level
+  const safeCount = analysisResult.byRisk.safe.length;
+  const moderateCount = analysisResult.byRisk.moderate.length;
+  const aggressiveCount = analysisResult.byRisk.aggressive.length;
+  
+  // Safe transformations
+  if (safeCount > 0) {
+    risks.push({
+      level: "safe",
+      count: safeCount,
+      description: "Safe transformations (cannot change behavior)",
+      recommendation: "Apply automatically",
+    });
+  }
+  
+  // Moderate transformations
+  if (moderateCount > 0) {
+    risks.push({
+      level: "moderate",
+      count: moderateCount,
+      description: "Moderate transformations (generally safe, worth reviewing)",
+      recommendation: "Review diff before applying",
+    });
+  }
+  
+  // Aggressive transformations
+  if (aggressiveCount > 0) {
+    risks.push({
+      level: "aggressive",
+      count: aggressiveCount,
+      description: "Aggressive transformations (could change behavior)",
+      recommendation: "Manual review required, use --aggressive --yes-i-am-sure",
+    });
+  }
+  
+  // Overall risk score (0-100)
+  const totalFindings = safeCount + moderateCount + aggressiveCount;
+  const riskScore = totalFindings > 0
+    ? Math.round((moderateCount * 25 + aggressiveCount * 75) / totalFindings)
+    : 0;
+  
+  return {
+    score: riskScore,
+    level: riskScore < 25 ? "low" : riskScore < 50 ? "moderate" : "high",
+    risks,
+    summary: {
+      safe: safeCount,
+      moderate: moderateCount,
+      aggressive: aggressiveCount,
+      total: totalFindings,
+    },
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  findFiles,
+  analyzeFile,
+  analyzeProject,
+  calculateFileDiff,
+  calculateDiffs,
+  applyTransformations,
+  rollbackTransformations,
+  assessRisk,
+  SCANNABLE_EXTENSIONS,
+  SKIP_DIRS,
+};

package/bin/runners/lib/cleanup/index.js

@@ -0,0 +1,53 @@
+/**
+ * vibecheck polish --cleanup Module Index
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * PRODUCTION-GRADE CLEANUP WITHOUT CHAOS
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
+"use strict";
+
+const rules = require("./rules");
+const engine = require("./engine");
+const output = require("./output");
+
+module.exports = {
+  // Rules
+  SAFE_RULES: rules.SAFE_RULES,
+  MODERATE_RULES: rules.MODERATE_RULES,
+  AGGRESSIVE_RULES: rules.AGGRESSIVE_RULES,
+  CATEGORIES: rules.CATEGORIES,
+  RISK_LEVELS: rules.RISK_LEVELS,
+  getAllRules: rules.getAllRules,
+  getSafeRules: rules.getSafeRules,
+  getModerateRules: rules.getModerateRules,
+  getAggressiveRules: rules.getAggressiveRules,
+  getRuleById: rules.getRuleById,
+  getRulesByCategory: rules.getRulesByCategory,
+  getRulesByRiskLevel: rules.getRulesByRiskLevel,
+  
+  // Engine
+  findFiles: engine.findFiles,
+  analyzeFile: engine.analyzeFile,
+  analyzeProject: engine.analyzeProject,
+  calculateFileDiff: engine.calculateFileDiff,
+  calculateDiffs: engine.calculateDiffs,
+  applyTransformations: engine.applyTransformations,
+  rollbackTransformations: engine.rollbackTransformations,
+  assessRisk: engine.assessRisk,
+  
+  // Output
+  printBanner: output.printBanner,
+  printAnalysisSummary: output.printAnalysisSummary,
+  printRiskAssessment: output.printRiskAssessment,
+  printFindingsByCategory: output.printFindingsByCategory,
+  printDiffPreview: output.printDiffPreview,
+  printApplyResults: output.printApplyResults,
+  printRollbackInfo: output.printRollbackInfo,
+  printAggressiveWarning: output.printAggressiveWarning,
+  printNextSteps: output.printNextSteps,
+  formatJsonOutput: output.formatJsonOutput,
+  colors: output.c,
+  icons: output.icons,
+};