vibeclean 1.0.0

package/src/index.js

@@ -0,0 +1,302 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { scanProject } from "./scanner.js";
+import { loadConfig, mergeConfig } from "./config.js";
+import { analyzeNaming } from "./analyzers/naming.js";
+import { analyzePatterns } from "./analyzers/patterns.js";
+import { analyzeLeftovers } from "./analyzers/leftovers.js";
+import { analyzeDependencies } from "./analyzers/dependencies.js";
+import { analyzeDeadCode } from "./analyzers/deadcode.js";
+import { analyzeErrorHandling } from "./analyzers/errorhandling.js";
+import { generateRulesFiles } from "./rules-generator.js";
+import { parseAstWithMeta } from "./analyzers/utils.js";
+import { applySafeFixes } from "./fixers/safe-fixes.js";
+import { compareAgainstBaseline, readBaselineSnapshot, resolveBaselinePath } from "./baseline.js";
+
+const SEVERITY_RANK = {
+  low: 1,
+  medium: 2,
+  high: 3
+};
+
+async function loadPackageJson(rootDir) {
+  const packagePath = path.join(rootDir, "package.json");
+  try {
+    const raw = await fs.readFile(packagePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function overallMessage(overallScore) {
+  if (overallScore >= 85) {
+    return "Clean and consistent. Keep the vibe under control.";
+  }
+  if (overallScore >= 65) {
+    return "Some inconsistency debt exists. A cleanup pass is worth it.";
+  }
+  if (overallScore >= 40) {
+    return "Your codebase has visible vibe coding debt and mixed patterns.";
+  }
+  return "Your codebase has significant vibe coding debt. Time for a cleanup sprint.";
+}
+
+function applySeverityFilter(categories, minimumSeverity = "low") {
+  const threshold = SEVERITY_RANK[minimumSeverity] || SEVERITY_RANK.low;
+
+  return categories
+    .map((category) => {
+      const findings = Array.isArray(category.findings) ? category.findings : [];
+      const filteredFindings =
+        threshold <= SEVERITY_RANK.low
+          ? findings
+          : findings.filter((finding) => (SEVERITY_RANK[finding.severity] || 1) >= threshold);
+
+      const keepCategory =
+        (SEVERITY_RANK[category.severity] || 1) >= threshold || filteredFindings.length > 0;
+
+      if (!keepCategory) {
+        return null;
+      }
+
+      const hasFindings = filteredFindings.length > 0;
+      const totalIssuesAtSeverity = hasFindings ? filteredFindings.length : 0;
+
+      return {
+        ...category,
+        findings: filteredFindings,
+        totalIssues:
+          threshold <= SEVERITY_RANK.low ? category.totalIssues : totalIssuesAtSeverity,
+        summary:
+          threshold <= SEVERITY_RANK.low || hasFindings
+            ? category.summary
+            : `No ${minimumSeverity}+ findings for this category.`
+      };
+    })
+    .filter(Boolean);
+}
+
+function collectParseWarnings(files) {
+  const warnings = [];
+  let hiddenCount = 0;
+
+  for (const file of files) {
+    const result = parseAstWithMeta(file.content);
+    if (!result.ast) {
+      if (warnings.length < 40) {
+        warnings.push(`Skipped AST analysis for ${file.relativePath} (syntax not parseable).`);
+      } else {
+        hiddenCount += 1;
+      }
+      continue;
+    }
+
+    if (result.usedTypeSyntaxFallback) {
+      if (warnings.length < 40) {
+        warnings.push(`Parsed ${file.relativePath} with TypeScript syntax fallback.`);
+      } else {
+        hiddenCount += 1;
+      }
+    }
+  }
+
+  if (hiddenCount > 0) {
+    warnings.push(`${hiddenCount} additional parse warnings were suppressed.`);
+  }
+
+  return warnings;
+}
+
+function collectGateFailures(report, config) {
+  const failures = [];
+
+  if (Number.isFinite(config.minScore) && report.overallScore < config.minScore) {
+    failures.push(
+      `Score gate failed: overall score ${report.overallScore} is below minimum ${config.minScore}.`
+    );
+  }
+
+  if (Number.isFinite(config.maxIssues) && report.totalIssues > config.maxIssues) {
+    failures.push(
+      `Issue gate failed: total issues ${report.totalIssues} exceeds maximum ${config.maxIssues}.`
+    );
+  }
+
+  if (config.failOn) {
+    const threshold = SEVERITY_RANK[config.failOn] || SEVERITY_RANK.high;
+    let matched = 0;
+    for (const category of report.categories) {
+      for (const finding of category.findings || []) {
+        const findingRank = SEVERITY_RANK[finding.severity] || SEVERITY_RANK.low;
+        if (findingRank >= threshold) {
+          matched += 1;
+        }
+      }
+    }
+
+    if (matched > 0) {
+      failures.push(
+        `Severity gate failed: found ${matched} finding(s) at ${config.failOn} severity or higher.`
+      );
+    }
+  }
+
+  return failures;
+}
+
+export async function runAudit(targetDir, cliOptions = {}) {
+  const startedAt = Date.now();
+  const rootDir = path.resolve(targetDir || process.cwd());
+
+  const baseConfig = await loadConfig(rootDir);
+  const config = mergeConfig(baseConfig, cliOptions);
+
+  const scanStart = Date.now();
+  const scanResult = await scanProject(rootDir, config);
+  scanResult.stats.durationMs = Date.now() - scanStart;
+  let fixesApplied = {
+    filesChanged: 0,
+    removedTodoLines: 0,
+    removedCommentedCodeLines: 0,
+    removedConsoleLines: 0
+  };
+
+  if (config.fix) {
+    fixesApplied = await applySafeFixes(scanResult.files);
+    if (fixesApplied.filesChanged > 0) {
+      scanResult.warnings.push(
+        `Applied safe fixes to ${fixesApplied.filesChanged} files before scoring.`
+      );
+    }
+  }
+
+  scanResult.warnings.push(...collectParseWarnings(scanResult.files));
+
+  if (scanResult.files.length === 0) {
+    const noFilesMessage = config.changedOnly
+      ? "No changed JS/TS source files found. Nothing to clean yet."
+      : "No JS/TS source files found. Nothing to clean yet.";
+    return {
+      rootDir,
+      config,
+      report: {
+        version: cliOptions.version || "1.0.0",
+        fileCount: 0,
+        durationSec: Number(((Date.now() - startedAt) / 1000).toFixed(2)),
+        categories: [],
+        totalIssues: 0,
+        overallScore: 100,
+        overallMessage: noFilesMessage,
+        scanWarnings: scanResult.warnings,
+        rulesGenerated: false,
+        fixesApplied,
+        profile: config.profile || "app",
+        gateFailures: [],
+        passedGates: true
+      },
+      generatedRules: []
+    };
+  }
+
+  const projectPackage = await loadPackageJson(rootDir);
+  const context = {
+    rootDir,
+    packageJson: projectPackage,
+    config
+  };
+
+  const enabledRules = config.rules || {};
+  const categoryResults = [];
+
+  if (enabledRules.naming !== false) {
+    categoryResults.push(analyzeNaming(scanResult.files));
+  }
+  if (enabledRules.patterns !== false) {
+    categoryResults.push(analyzePatterns(scanResult.files, context));
+  }
+  if (enabledRules.leftovers !== false) {
+    categoryResults.push(analyzeLeftovers(scanResult.files, context));
+  }
+  if (enabledRules.dependencies !== false) {
+    categoryResults.push(await analyzeDependencies(scanResult.files, context));
+  }
+  if (enabledRules.deadcode !== false) {
+    categoryResults.push(analyzeDeadCode(scanResult.files, context));
+  }
+  if (enabledRules.errorhandling !== false) {
+    categoryResults.push(analyzeErrorHandling(scanResult.files, context));
+  }
+
+  const filteredCategories = applySeverityFilter(categoryResults, config.severity || "low");
+
+  const averageIssueScore = filteredCategories.length
+    ? filteredCategories.reduce((sum, category) => sum + category.score, 0) / filteredCategories.length
+    : 0;
+
+  const overallScore = Math.max(0, Math.min(100, Math.round(100 - averageIssueScore * 10)));
+  const totalIssues = filteredCategories.reduce((sum, category) => sum + (category.totalIssues || 0), 0);
+
+  const report = {
+    version: cliOptions.version || "1.0.0",
+    rootDir,
+    fileCount: scanResult.files.length,
+    durationSec: Number(((Date.now() - startedAt) / 1000).toFixed(2)),
+    categories: filteredCategories,
+    totalIssues,
+    overallScore,
+    overallMessage: overallMessage(overallScore),
+    scanWarnings: scanResult.warnings,
+    rulesGenerated: false,
+    fixesApplied,
+    profile: config.profile || "app"
+  };
+
+  if (config.baseline) {
+    try {
+      const baselineData = await readBaselineSnapshot(rootDir, config.baselineFile);
+      report.baselineComparison = {
+        path: baselineData.path,
+        ...compareAgainstBaseline(report, baselineData.snapshot)
+      };
+    } catch {
+      const baselinePath = resolveBaselinePath(rootDir, config.baselineFile);
+      report.scanWarnings.push(`Baseline file not found or invalid: ${baselinePath}`);
+      report.baselineComparison = {
+        path: baselinePath,
+        regressions: [],
+        missing: true
+      };
+    }
+  }
+
+  report.gateFailures = collectGateFailures(report, config);
+  if (
+    config.failOnRegression !== false &&
+    report.baselineComparison &&
+    Array.isArray(report.baselineComparison.regressions) &&
+    report.baselineComparison.regressions.length > 0
+  ) {
+    report.gateFailures.push(...report.baselineComparison.regressions);
+  }
+  report.passedGates = report.gateFailures.length === 0;
+
+  let generatedRules = [];
+  if (cliOptions.rules || cliOptions.cursor || cliOptions.claude) {
+    const ruleOutput = await generateRulesFiles(report, {
+      rootDir,
+      cursor: Boolean(cliOptions.cursor),
+      claude: Boolean(cliOptions.claude),
+      config
+    });
+    generatedRules = ruleOutput.generated;
+    report.rulesGenerated = generatedRules.length > 0;
+  }
+
+  return {
+    rootDir,
+    config,
+    report,
+    generatedRules
+  };
+}

package/src/markdown-report.js

@@ -0,0 +1,90 @@
+function escapePipes(value = "") {
+  return String(value).replace(/\|/g, "\\|");
+}
+
+function topFindings(categories, limit = 8) {
+  const rows = [];
+  for (const category of categories || []) {
+    for (const finding of category.findings || []) {
+      rows.push({
+        category: category.id,
+        severity: finding.severity || "low",
+        message: finding.message || ""
+      });
+    }
+  }
+
+  const severityRank = { high: 3, medium: 2, low: 1 };
+  rows.sort((a, b) => (severityRank[b.severity] || 0) - (severityRank[a.severity] || 0));
+  return rows.slice(0, limit);
+}
+
+export function renderMarkdownReport(report) {
+  const lines = [];
+  const gateStatus = report.passedGates ? "PASS" : "FAIL";
+
+  lines.push("# Vibeclean PR Report");
+  lines.push("");
+  lines.push(`- **Score:** ${report.overallScore}/100`);
+  lines.push(`- **Total Issues:** ${report.totalIssues}`);
+  lines.push(`- **Files Scanned:** ${report.fileCount}`);
+  lines.push(`- **Profile:** ${report.profile || "app"}`);
+  lines.push(`- **Quality Gates:** ${gateStatus}`);
+  lines.push(`- **Duration:** ${report.durationSec}s`);
+
+  if (report.baselineComparison && !report.baselineComparison.missing) {
+    const deltas = report.baselineComparison.deltas || {};
+    const scoreDelta = Number.isFinite(deltas.score) ? deltas.score : 0;
+    const issueDelta = Number.isFinite(deltas.totalIssues) ? deltas.totalIssues : 0;
+    lines.push(
+      `- **Baseline:** score ${report.baselineComparison.baselineScore} -> ${report.baselineComparison.currentScore} (${scoreDelta >= 0 ? "+" : ""}${scoreDelta}), issues ${report.baselineComparison.baselineTotalIssues} -> ${report.baselineComparison.currentTotalIssues} (${issueDelta >= 0 ? "+" : ""}${issueDelta})`
+    );
+  } else if (report.baselineComparison?.missing) {
+    lines.push(`- **Baseline:** missing (${report.baselineComparison.path})`);
+  }
+
+  lines.push("");
+  lines.push("## Category Summary");
+  lines.push("");
+  lines.push("| Category | Score | Severity | Issues |");
+  lines.push("|---|---:|---|---:|");
+  for (const category of report.categories || []) {
+    lines.push(
+      `| ${escapePipes(category.title)} | ${category.score}/10 | ${String(
+        category.severity || "low"
+      ).toUpperCase()} | ${category.totalIssues || 0} |`
+    );
+  }
+
+  const findings = topFindings(report.categories);
+  if (findings.length > 0) {
+    lines.push("");
+    lines.push("## Top Findings");
+    lines.push("");
+    for (const finding of findings) {
+      lines.push(
+        `- [${String(finding.severity).toUpperCase()}] \`${finding.category}\` ${finding.message}`
+      );
+    }
+  }
+
+  if (report.gateFailures?.length) {
+    lines.push("");
+    lines.push("## Gate Failures");
+    lines.push("");
+    for (const failure of report.gateFailures) {
+      lines.push(`- ${failure}`);
+    }
+  }
+
+  if (report.scanWarnings?.length) {
+    lines.push("");
+    lines.push("## Scan Warnings");
+    lines.push("");
+    for (const warning of report.scanWarnings.slice(0, 10)) {
+      lines.push(`- ${warning}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/src/reporter.js

@@ -0,0 +1,200 @@
+import chalk from "chalk";
+
+function colorForScore(score) {
+  if (score >= 7) {
+    return chalk.red;
+  }
+  if (score >= 4) {
+    return chalk.yellow;
+  }
+  return chalk.green;
+}
+
+function iconForScore(score) {
+  if (score >= 7) {
+    return "🚨";
+  }
+  if (score >= 1) {
+    return "⚠️";
+  }
+  return "✅";
+}
+
+function divider() {
+  return chalk.gray("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+}
+
+function renderFindings(category) {
+  const findings = Array.isArray(category.findings) ? category.findings.slice(0, 2) : [];
+  const lines = [];
+
+  for (const finding of findings) {
+    lines.push(
+      `   ${chalk.gray("•")} ${chalk.bold(
+        `[${(finding.severity || "low").toUpperCase()}]`
+      )} ${finding.message}`
+    );
+
+    const locations = Array.isArray(finding.locations) ? finding.locations.slice(0, 2) : [];
+    for (const location of locations) {
+      const snippet = location.snippet ? ` ${chalk.gray(`— ${location.snippet}`)}` : "";
+      lines.push(`     ${chalk.gray("↳")} ${location.file}:${location.line}${snippet}`);
+    }
+  }
+
+  return lines;
+}
+
+function categoryDetailLines(category) {
+  const metrics = category.metrics || {};
+
+  switch (category.id) {
+    case "naming": {
+      const styles = metrics.identifierStyles || [];
+      const top = styles
+        .slice(0, 2)
+        .map((item) => `${item.style}: ${item.percent}% (${item.count})`)
+        .join(", ");
+      return [
+        top ? `├─ ${top}` : "├─ Not enough identifier samples",
+        `├─ Mixed directories: ${metrics.mixedDirectoryCount || 0}`,
+        `└─ Component filename mismatches: ${metrics.componentMismatchCount || 0}`
+      ];
+    }
+
+    case "patterns": {
+      const httpClients = metrics.httpClients || {};
+      const httpText = Object.entries(httpClients)
+        .map(([name, count]) => `${name} (${count})`)
+        .join(", ");
+      const asyncTotal = (metrics.asyncAwaitOps || 0) + (metrics.thenChains || 0);
+      const asyncAwaitPct = asyncTotal
+        ? Math.round(((metrics.asyncAwaitOps || 0) / asyncTotal) * 100)
+        : 100;
+      const thenPct = asyncTotal ? 100 - asyncAwaitPct : 0;
+      return [
+        `├─ HTTP clients: ${httpText || "none detected"}`,
+        `├─ Mixed async: async/await (${asyncAwaitPct}%), .then() (${thenPct}%)`,
+        `└─ Module style: import files ${metrics.filesUsingImport || 0}, require files ${metrics.filesUsingRequire || 0}`
+      ];
+    }
+
+    case "leftovers":
+      return [
+        `├─ console.* statements: ${metrics.consoleCount || 0}`,
+        `├─ TODO/FIXME markers: ${metrics.todoCount || 0} (${metrics.aiTodoCount || 0} AI-like)`,
+        `└─ Placeholders/localhost: ${(metrics.placeholderCount || 0) + (metrics.localhostCount || 0)}`
+      ];
+
+    case "dependencies":
+      return [
+        `├─ Unused packages: ${metrics.unusedCount || 0}`,
+        `├─ Duplicate groups: ${(metrics.duplicateGroups || []).length}`,
+        `└─ Estimated savings: ~${metrics.estimatedSavingsMb || 0}MB`
+      ];
+
+    case "deadcode":
+      return [
+        `├─ Orphan files: ${(metrics.orphanFiles || []).length}`,
+        `├─ Unused exports: ${(metrics.unusedExports || []).length}`,
+        `└─ Stub files: ${(metrics.stubFiles || []).length}`
+      ];
+
+    case "errorhandling":
+      return [
+        `├─ Functions with try/catch: ${metrics.handledRate || 0}%`,
+        `├─ Empty catch blocks: ${metrics.emptyCatch || 0}`,
+        `└─ Unhandled await signals: ${metrics.unhandledAwait || 0}`
+      ];
+
+    default:
+      return ["└─ No details available"];
+  }
+}
+
+function renderCategory(category, options = {}) {
+  const color = colorForScore(category.score);
+  const scoreText = color(`Score: ${category.score}/10`);
+
+  const header = `${iconForScore(category.score)}  ${chalk.bold(category.title.padEnd(42))} ${scoreText}`;
+
+  if (options.quiet) {
+    return `${header}\n${chalk.gray(`   ${category.summary}`)}`;
+  }
+
+  const detailLines = categoryDetailLines(category);
+  const findingLines = renderFindings(category);
+  const recommendation = category.recommendations?.[0]
+    ? `   ${chalk.cyan(`Recommendation: ${category.recommendations[0]}`)}`
+    : "";
+
+  return [header, ...detailLines.map((line) => `   ${line}`), ...findingLines, recommendation]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function renderReport(report, options = {}) {
+  const lines = [];
+
+  lines.push(`  🧹 ${chalk.bold(`vibeclean v${report.version}`)} ${chalk.gray("— Cleaning up the vibe")}`);
+  lines.push("");
+  lines.push(
+    `  Scanning project... ${chalk.green("✓")} Found ${chalk.bold(report.fileCount)} source files in ${chalk.bold(`${report.durationSec}s`)}`
+  );
+  lines.push(`  Profile: ${chalk.bold(report.profile || "app")}`);
+
+  if (report.baselineComparison && !report.baselineComparison.missing) {
+    const deltas = report.baselineComparison.deltas || {};
+    const scoreDelta = Number.isFinite(deltas.score) ? deltas.score : 0;
+    const issueDelta = Number.isFinite(deltas.totalIssues) ? deltas.totalIssues : 0;
+    lines.push(
+      `  Baseline: score ${report.baselineComparison.baselineScore} -> ${report.baselineComparison.currentScore} (${scoreDelta >= 0 ? "+" : ""}${scoreDelta}), issues ${report.baselineComparison.baselineTotalIssues} -> ${report.baselineComparison.currentTotalIssues} (${issueDelta >= 0 ? "+" : ""}${issueDelta})`
+    );
+  }
+
+  if (report.scanWarnings?.length) {
+    for (const warning of report.scanWarnings.slice(0, 6)) {
+      lines.push(`  ${chalk.yellow("•")} ${chalk.yellow(warning)}`);
+    }
+    if (report.scanWarnings.length > 6) {
+      lines.push(`  ${chalk.yellow("•")} ${chalk.yellow(`+${report.scanWarnings.length - 6} more warnings`)}`);
+    }
+  }
+
+  lines.push("");
+  lines.push(`  ${divider()}`);
+  lines.push("");
+
+  for (const category of report.categories) {
+    lines.push(`  ${renderCategory(category, options)}`);
+    lines.push("");
+  }
+
+  lines.push(`  ${divider()}`);
+  lines.push("");
+
+  const overallColor =
+    report.overallScore >= 80
+      ? chalk.green
+      : report.overallScore >= 60
+        ? chalk.yellow
+        : chalk.red;
+
+  lines.push(`  📊 ${chalk.bold("VIBE CLEANLINESS SCORE")}: ${overallColor.bold(`${report.overallScore}/100`)}`);
+  lines.push(`     ${overallColor(report.overallMessage)}`);
+  lines.push("");
+  lines.push(`  🧹 Found ${chalk.bold(report.totalIssues)} issues across ${chalk.bold(report.categories.length)} categories`);
+
+  if (report.fixesApplied?.filesChanged > 0) {
+    const fixStats = report.fixesApplied;
+    lines.push(
+      `  🛠️  Applied safe fixes in ${chalk.bold(fixStats.filesChanged)} files (${fixStats.removedTodoLines} TODO/comments, ${fixStats.removedConsoleLines} console lines, ${fixStats.removedCommentedCodeLines} commented code lines)`
+    );
+  }
+
+  if (!report.rulesGenerated) {
+    lines.push(`  📋 Run ${chalk.bold("vibeclean --rules")} to generate AI rules file`);
+  }
+
+  return lines.join("\n");
+}