vibeclean 1.0.0

package/src/analyzers/utils.js

@@ -0,0 +1,204 @@
+import * as acorn from "acorn";
+import jsx from "acorn-jsx";
+import * as walk from "acorn-walk";
+
+const AcornWithJsx = acorn.Parser.extend(jsx());
+
+const IMPORT_RE = /import\s+[^"'`]*?from\s+["'`]([^"'`]+)["'`]|import\s+["'`]([^"'`]+)["'`]/g;
+const REQUIRE_RE = /require\(\s*["'`]([^"'`]+)["'`]\s*\)/g;
+
+function stripTypeOnlySyntax(content) {
+  return content
+    .replace(/\bimport\s+type\s+/g, "import ")
+    .replace(/\bexport\s+type\s+\{[^}]*\}\s+from\s+["'`][^"'`]+["'`];?/g, "")
+    .replace(/\b(?:export\s+)?interface\s+[A-Za-z_$][A-Za-z0-9_$]*[\s\S]*?\}\s*/g, "")
+    .replace(/\b(?:export\s+)?type\s+[A-Za-z_$][A-Za-z0-9_$]*\s*=\s*[^;]+;/g, "")
+    .replace(/\s+as\s+const\b/g, "");
+}
+
+function tryParse(content, sourceType) {
+  try {
+    return {
+      ast: AcornWithJsx.parse(content, {
+        ecmaVersion: "latest",
+        sourceType,
+        allowHashBang: true
+      }),
+      error: null
+    };
+  } catch (error) {
+    return { ast: null, error };
+  }
+}
+
+export function parseAstWithMeta(content) {
+  const moduleResult = tryParse(content, "module");
+  if (moduleResult.ast) {
+    return { ast: moduleResult.ast, parseError: null, usedTypeSyntaxFallback: false };
+  }
+
+  const scriptResult = tryParse(content, "script");
+  if (scriptResult.ast) {
+    return { ast: scriptResult.ast, parseError: null, usedTypeSyntaxFallback: false };
+  }
+
+  const stripped = stripTypeOnlySyntax(content);
+  if (stripped !== content) {
+    const moduleStripped = tryParse(stripped, "module");
+    if (moduleStripped.ast) {
+      return { ast: moduleStripped.ast, parseError: moduleResult.error, usedTypeSyntaxFallback: true };
+    }
+
+    const scriptStripped = tryParse(stripped, "script");
+    if (scriptStripped.ast) {
+      return { ast: scriptStripped.ast, parseError: moduleResult.error, usedTypeSyntaxFallback: true };
+    }
+  }
+
+  return { ast: null, parseError: moduleResult.error || scriptResult.error, usedTypeSyntaxFallback: false };
+}
+
+export function parseAst(content) {
+  const result = parseAstWithMeta(content);
+  return result.ast;
+}
+
+function collectIdentifiersFallback(content) {
+  const names = new Set();
+  const reserved = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "function",
+    "class",
+    "const",
+    "let",
+    "var",
+    "import",
+    "export",
+    "default",
+    "new",
+    "typeof"
+  ]);
+  const patterns = [
+    /\b(?:const|let|var|function|class|interface|type|enum)\s+([A-Za-z_$][A-Za-z0-9_$]*)/g,
+    /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/g,
+    /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/g
+  ];
+
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      const value = match[1];
+      if (!reserved.has(value)) {
+        names.add(value);
+      }
+    }
+  }
+
+  return [...names];
+}
+
+export function traverseAst(node, onNode) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+
+  onNode(node);
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    if (!value) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        if (child && typeof child.type === "string") {
+          traverseAst(child, onNode);
+        }
+      }
+    } else if (value && typeof value.type === "string") {
+      traverseAst(value, onNode);
+    }
+  }
+}
+
+export function collectIdentifiers(content) {
+  const ast = parseAst(content);
+  if (!ast) {
+    return collectIdentifiersFallback(content);
+  }
+
+  const names = [];
+  // Use acorn-walk when possible, then fall back to generic traversal for JSX-heavy files.
+  try {
+    walk.full(ast, (node) => {
+      if (node.type === "Identifier" && typeof node.name === "string") {
+        names.push(node.name);
+      }
+    });
+  } catch {
+    traverseAst(ast, (node) => {
+      if (node.type === "Identifier" && typeof node.name === "string") {
+        names.push(node.name);
+      }
+    });
+  }
+
+  return names;
+}
+
+export function collectImportSpecifiers(content) {
+  const imports = new Set();
+
+  for (const match of content.matchAll(IMPORT_RE)) {
+    const spec = match[1] || match[2];
+    if (spec) {
+      imports.add(spec);
+    }
+  }
+
+  for (const match of content.matchAll(REQUIRE_RE)) {
+    if (match[1]) {
+      imports.add(match[1]);
+    }
+  }
+
+  return [...imports];
+}
+
+export function packageRoot(specifier) {
+  if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) {
+    return null;
+  }
+
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+  }
+
+  return specifier.split("/")[0];
+}
+
+export function countMatches(content, regex) {
+  const matches = content.match(regex);
+  return matches ? matches.length : 0;
+}
+
+export function severityFromScore(score) {
+  if (score >= 7) {
+    return "high";
+  }
+  if (score >= 4) {
+    return "medium";
+  }
+  return "low";
+}
+
+export function scoreFromRatio(ratio, weight = 10) {
+  const bounded = Math.min(1, Math.max(0, ratio));
+  return Math.round(bounded * weight);
+}
+

package/src/baseline.js

@@ -0,0 +1,134 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function countFindingsBySeverity(categories = []) {
+  const counts = {
+    low: 0,
+    medium: 0,
+    high: 0
+  };
+
+  for (const category of categories) {
+    for (const finding of category.findings || []) {
+      const severity = finding.severity || "low";
+      if (severity in counts) {
+        counts[severity] += 1;
+      } else {
+        counts.low += 1;
+      }
+    }
+  }
+
+  return counts;
+}
+
+function categorySnapshot(categories = []) {
+  const map = {};
+  for (const category of categories) {
+    map[category.id] = {
+      score: category.score,
+      totalIssues: category.totalIssues,
+      severity: category.severity
+    };
+  }
+  return map;
+}
+
+export function resolveBaselinePath(rootDir, baselineFile = ".vibeclean-baseline.json") {
+  if (path.isAbsolute(baselineFile)) {
+    return baselineFile;
+  }
+  return path.join(rootDir, baselineFile);
+}
+
+export function buildBaselineSnapshot(report) {
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    overallScore: report.overallScore,
+    totalIssues: report.totalIssues,
+    findingCounts: countFindingsBySeverity(report.categories),
+    categories: categorySnapshot(report.categories)
+  };
+}
+
+export async function readBaselineSnapshot(rootDir, baselineFile) {
+  const fullPath = resolveBaselinePath(rootDir, baselineFile);
+  const raw = await fs.readFile(fullPath, "utf8");
+  return {
+    path: fullPath,
+    snapshot: JSON.parse(raw)
+  };
+}
+
+export async function writeBaselineSnapshot(rootDir, baselineFile, report) {
+  const fullPath = resolveBaselinePath(rootDir, baselineFile);
+  const snapshot = buildBaselineSnapshot(report);
+  await fs.writeFile(fullPath, `${JSON.stringify(snapshot, null, 2)}\n`, "utf8");
+  return {
+    path: fullPath,
+    snapshot
+  };
+}
+
+export function compareAgainstBaseline(report, baselineSnapshot) {
+  const currentFindingCounts = countFindingsBySeverity(report.categories);
+  const baselineFindingCounts = baselineSnapshot.findingCounts || {
+    low: 0,
+    medium: 0,
+    high: 0
+  };
+
+  const deltas = {
+    score: report.overallScore - (baselineSnapshot.overallScore || 0),
+    totalIssues: report.totalIssues - (baselineSnapshot.totalIssues || 0),
+    highFindings: currentFindingCounts.high - (baselineFindingCounts.high || 0),
+    mediumFindings: currentFindingCounts.medium - (baselineFindingCounts.medium || 0)
+  };
+
+  const regressions = [];
+  if (deltas.score < 0) {
+    regressions.push(
+      `Baseline regression: overall score dropped by ${Math.abs(deltas.score)} (from ${baselineSnapshot.overallScore} to ${report.overallScore}).`
+    );
+  }
+  if (deltas.totalIssues > 0) {
+    regressions.push(
+      `Baseline regression: total issues increased by ${deltas.totalIssues} (from ${baselineSnapshot.totalIssues} to ${report.totalIssues}).`
+    );
+  }
+  if (deltas.highFindings > 0) {
+    regressions.push(
+      `Baseline regression: high-severity findings increased by ${deltas.highFindings}.`
+    );
+  }
+
+  const baselineCategoryMap = baselineSnapshot.categories || {};
+  const worsenedCategories = [];
+  for (const category of report.categories) {
+    const previous = baselineCategoryMap[category.id];
+    if (!previous) {
+      continue;
+    }
+    const scoreDelta = category.score - (previous.score || 0);
+    if (scoreDelta > 0) {
+      worsenedCategories.push(`${category.id} (+${scoreDelta})`);
+    }
+  }
+
+  if (worsenedCategories.length > 0) {
+    regressions.push(
+      `Baseline regression: category scores worsened in ${worsenedCategories.join(", ")}.`
+    );
+  }
+
+  return {
+    baselineGeneratedAt: baselineSnapshot.generatedAt || null,
+    baselineScore: baselineSnapshot.overallScore ?? null,
+    baselineTotalIssues: baselineSnapshot.totalIssues ?? null,
+    currentScore: report.overallScore,
+    currentTotalIssues: report.totalIssues,
+    deltas,
+    regressions
+  };
+}

package/src/config.js

@@ -0,0 +1,207 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_CONFIG = {
+  maxFiles: 500,
+  maxFileSizeKb: 100,
+  ignore: [],
+  severity: "low",
+  profile: "app",
+  changedOnly: false,
+  changedBase: "HEAD",
+  failOn: null,
+  maxIssues: null,
+  minScore: null,
+  baseline: false,
+  baselineFile: ".vibeclean-baseline.json",
+  writeBaseline: false,
+  failOnRegression: true,
+  reportFormat: "text",
+  reportFile: null,
+  leftovers: {
+    allowConsolePaths: [],
+    ignoreTodoPaths: []
+  },
+  rules: {
+    naming: true,
+    patterns: true,
+    leftovers: true,
+    dependencies: true,
+    deadcode: true,
+    errorhandling: true
+  },
+  allowedPatterns: {
+    httpClient: null,
+    asyncStyle: null,
+    stateManagement: null
+  }
+};
+const VALID_SEVERITIES = new Set(["low", "medium", "high"]);
+const VALID_REPORT_FORMATS = new Set(["text", "json", "markdown"]);
+
+const PROFILE_PRESETS = {
+  app: {
+    ignore: []
+  },
+  library: {
+    ignore: ["examples/**", "example/**", "benchmarks/**", "benchmark/**", "playground/**"]
+  },
+  cli: {
+    ignore: ["test/**", "**/*.test.js", "**/*.spec.js"],
+    leftovers: {
+      allowConsolePaths: ["bin/", "scripts/", "test/"],
+      ignoreTodoPaths: ["test/"]
+    }
+  }
+};
+const VALID_PROFILES = new Set(Object.keys(PROFILE_PRESETS));
+
+function deepMerge(base, override) {
+  const merged = { ...base };
+
+  for (const [key, value] of Object.entries(override || {})) {
+    if (
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      typeof merged[key] === "object" &&
+      !Array.isArray(merged[key])
+    ) {
+      merged[key] = deepMerge(merged[key], value);
+    } else {
+      merged[key] = value;
+    }
+  }
+
+  return merged;
+}
+
+async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+
+function uniqueArray(input) {
+  return [...new Set((Array.isArray(input) ? input : []).filter(Boolean))];
+}
+
+function applyProfile(baseConfig, profileName) {
+  const normalized = typeof profileName === "string" ? profileName.toLowerCase() : "";
+  const selectedProfile = VALID_PROFILES.has(normalized) ? normalized : DEFAULT_CONFIG.profile;
+  const profilePreset = PROFILE_PRESETS[selectedProfile] || {};
+  const profiled = deepMerge(baseConfig, profilePreset);
+  profiled.profile = selectedProfile;
+  profiled.ignore = uniqueArray([...(baseConfig.ignore || []), ...(profilePreset.ignore || [])]);
+  return profiled;
+}
+
+export async function loadConfig(rootDir) {
+  const candidates = [".vibecleanrc", ".vibecleanrc.json"];
+  let fileConfig = {};
+
+  for (const candidate of candidates) {
+    const fullPath = path.join(rootDir, candidate);
+    try {
+      const stats = await fs.stat(fullPath);
+      if (!stats.isFile()) {
+        continue;
+      }
+      fileConfig = await readJson(fullPath);
+      break;
+    } catch {
+      // Missing file or invalid stats: try next config candidate.
+    }
+  }
+
+  return deepMerge(DEFAULT_CONFIG, fileConfig);
+}
+
+export function mergeConfig(base, overrides) {
+  const safeOverrides = { ...overrides };
+  const extraIgnore = [];
+  if (safeOverrides.ignore && typeof safeOverrides.ignore === "string") {
+    extraIgnore.push(
+      ...safeOverrides.ignore
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+    );
+    delete safeOverrides.ignore;
+  } else if (Array.isArray(safeOverrides.ignore)) {
+    extraIgnore.push(...safeOverrides.ignore.filter(Boolean));
+    delete safeOverrides.ignore;
+  }
+
+  if (typeof safeOverrides.maxFiles === "string") {
+    safeOverrides.maxFiles = Number.parseInt(safeOverrides.maxFiles, 10);
+  }
+
+  if (typeof safeOverrides.maxIssues === "string") {
+    safeOverrides.maxIssues = Number.parseInt(safeOverrides.maxIssues, 10);
+  }
+
+  if (typeof safeOverrides.minScore === "string") {
+    safeOverrides.minScore = Number.parseInt(safeOverrides.minScore, 10);
+  }
+
+  if (typeof safeOverrides.minSeverity === "string") {
+    safeOverrides.severity = safeOverrides.minSeverity.toLowerCase();
+  }
+
+  if (typeof safeOverrides.profile === "string") {
+    safeOverrides.profile = safeOverrides.profile.toLowerCase();
+    if (!VALID_PROFILES.has(safeOverrides.profile)) {
+      delete safeOverrides.profile;
+    }
+  }
+
+  if (typeof safeOverrides.severity === "string") {
+    safeOverrides.severity = safeOverrides.severity.toLowerCase();
+    if (!VALID_SEVERITIES.has(safeOverrides.severity)) {
+      safeOverrides.severity = base.severity || DEFAULT_CONFIG.severity;
+    }
+  }
+
+  if (!Number.isFinite(safeOverrides.maxFiles) || safeOverrides.maxFiles <= 0) {
+    delete safeOverrides.maxFiles;
+  }
+
+  if (!Number.isFinite(safeOverrides.maxIssues) || safeOverrides.maxIssues < 0) {
+    delete safeOverrides.maxIssues;
+  }
+
+  if (!Number.isFinite(safeOverrides.minScore)) {
+    delete safeOverrides.minScore;
+  } else {
+    safeOverrides.minScore = Math.max(0, Math.min(100, Math.round(safeOverrides.minScore)));
+  }
+
+  if (typeof safeOverrides.failOn === "string") {
+    safeOverrides.failOn = safeOverrides.failOn.toLowerCase();
+    if (!VALID_SEVERITIES.has(safeOverrides.failOn)) {
+      safeOverrides.failOn = null;
+    }
+  } else if (safeOverrides.failOn != null) {
+    safeOverrides.failOn = null;
+  }
+
+  if (typeof safeOverrides.reportFormat === "string") {
+    safeOverrides.reportFormat = safeOverrides.reportFormat.toLowerCase();
+    if (!VALID_REPORT_FORMATS.has(safeOverrides.reportFormat)) {
+      safeOverrides.reportFormat = base.reportFormat || DEFAULT_CONFIG.reportFormat;
+    }
+  }
+
+  if (typeof safeOverrides.baselineFile === "string") {
+    safeOverrides.baselineFile = safeOverrides.baselineFile.trim() || DEFAULT_CONFIG.baselineFile;
+  }
+
+  const selectedProfile = safeOverrides.profile || base.profile || DEFAULT_CONFIG.profile;
+  const profiledBase = applyProfile(base, selectedProfile);
+  const merged = deepMerge(profiledBase, safeOverrides);
+  merged.ignore = uniqueArray([...(profiledBase.ignore || []), ...extraIgnore]);
+
+  return merged;
+}
+
+export { DEFAULT_CONFIG, PROFILE_PRESETS };

package/src/fixers/safe-fixes.js

@@ -0,0 +1,125 @@
+import fs from "node:fs/promises";
+
+const TODO_LINE_RE = /^\s*\/\/\s*(TODO|FIXME|HACK|XXX)\b/i;
+const AI_COMMENT_LINE_RE = /^\s*\/\/\s*(AI generated|Generated by|Created by Copilot)\b/i;
+const NOISY_CONSOLE_LINE_RE = /^\s*console\.(log|debug|trace)\s*\(.*\)\s*;?\s*$/;
+const CODE_LIKE_COMMENT_RE =
+  /^\s*\/\/.*(?:[;{}()[\]=]|\b(const|let|var|if|for|while|return|import|export|function|class)\b)/;
+
+function identifyCommentedCodeLines(lines) {
+  const removable = new Set();
+  let streak = [];
+
+  const flush = () => {
+    if (streak.length >= 3) {
+      for (const lineIndex of streak) {
+        removable.add(lineIndex);
+      }
+    }
+    streak = [];
+  };
+
+  for (let i = 0; i < lines.length; i += 1) {
+    if (CODE_LIKE_COMMENT_RE.test(lines[i])) {
+      streak.push(i);
+      continue;
+    }
+    flush();
+  }
+  flush();
+
+  return removable;
+}
+
+function transformContent(content) {
+  const lines = content.split("\n");
+  const commentedCodeLines = identifyCommentedCodeLines(lines);
+
+  const stats = {
+    removedTodoLines: 0,
+    removedCommentedCodeLines: 0,
+    removedConsoleLines: 0,
+    filesChanged: 0
+  };
+
+  const kept = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+
+    if (commentedCodeLines.has(i)) {
+      stats.removedCommentedCodeLines += 1;
+      continue;
+    }
+
+    if (TODO_LINE_RE.test(line) || AI_COMMENT_LINE_RE.test(line)) {
+      stats.removedTodoLines += 1;
+      continue;
+    }
+
+    if (NOISY_CONSOLE_LINE_RE.test(line)) {
+      stats.removedConsoleLines += 1;
+      continue;
+    }
+
+    kept.push(line);
+  }
+
+  const trimmed = [];
+  let blankStreak = 0;
+  for (const line of kept) {
+    if (line.trim() === "") {
+      blankStreak += 1;
+      if (blankStreak > 2) {
+        continue;
+      }
+    } else {
+      blankStreak = 0;
+    }
+    trimmed.push(line);
+  }
+
+  const nextContent =
+    content.endsWith("\n") || content.length === 0 ? `${trimmed.join("\n")}\n` : trimmed.join("\n");
+  const changed = nextContent !== content;
+  if (changed) {
+    stats.filesChanged = 1;
+  }
+
+  return {
+    changed,
+    content: nextContent,
+    stats
+  };
+}
+
+export async function applySafeFixes(files) {
+  const updates = [];
+  const totals = {
+    filesChanged: 0,
+    removedTodoLines: 0,
+    removedCommentedCodeLines: 0,
+    removedConsoleLines: 0
+  };
+
+  for (const file of files) {
+    const result = transformContent(file.content);
+    if (!result.changed) {
+      continue;
+    }
+
+    updates.push(
+      fs.writeFile(file.path, result.content, "utf8").then(() => {
+        file.content = result.content;
+      })
+    );
+
+    totals.filesChanged += result.stats.filesChanged;
+    totals.removedTodoLines += result.stats.removedTodoLines;
+    totals.removedCommentedCodeLines += result.stats.removedCommentedCodeLines;
+    totals.removedConsoleLines += result.stats.removedConsoleLines;
+  }
+
+  await Promise.all(updates);
+  return totals;
+}
+