@vhite/vhite 0.0.0-stage → 0.1.0

package/src/safe-fix.js

@@ -0,0 +1,178 @@
+import {
+  readFile,
+  writeFile,
+} from "node:fs/promises";
+import { runRules } from "./engine.js";
+import {
+  fixers as defaultFixers,
+} from "./fixers/index.js";
+import {
+  prepareBackupDir,
+  saveBackup,
+  restoreBackup,
+} from "./backup.js";
+
+function summarize(issues) {
+  const counts = new Map();
+
+  for (const issue of issues) {
+    const key = `${issue.rule}|${issue.message}`;
+
+    counts.set(
+      key,
+      (counts.get(key) ?? 0) + 1
+    );
+  }
+
+  return counts;
+}
+
+function isExpectedAfterFix(before, after, key) {
+  const expected = new Map(before);
+
+  if (!expected.get(key)) {
+    return false;
+  }
+
+  const remaining = expected.get(key) - 1;
+
+  if (remaining === 0) {
+    expected.delete(key);
+  } else {
+    expected.set(key, remaining);
+  }
+
+  if (expected.size !== after.size) {
+    return false;
+  }
+
+  for (const [name, count] of expected) {
+    if (after.get(name) !== count) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export async function proposeFixes(
+  issues,
+  { fixers = defaultFixers } = {}
+) {
+  const proposals = [];
+
+  for (const issue of issues) {
+    const fixer = fixers[issue.rule];
+
+    if (!fixer) {
+      continue;
+    }
+
+    const source = await readFile(issue.file, "utf8");
+
+    if (fixer.apply(source, issue) === null) {
+      continue;
+    }
+
+    const lineText = (
+      source.split("\n")[issue.line - 1] ?? ""
+    ).trim();
+
+    proposals.push({
+      ...issue,
+      lineText,
+    });
+  }
+
+  return proposals;
+}
+
+export async function applyApprovedFixes(
+  root,
+  proposals,
+  {
+    fixers = defaultFixers,
+    disabledRules = new Set(),
+  } = {}
+) {
+  const { changed } = await prepareBackupDir(root);
+  const results = [];
+
+  const ordered = [...proposals].sort(
+    (a, b) =>
+      a.file.localeCompare(b.file) ||
+      b.line - a.line
+  );
+
+  let attempt = 0;
+
+  for (const proposal of ordered) {
+    attempt += 1;
+
+    const fixer = fixers[proposal.rule];
+
+    if (!fixer) {
+      results.push({
+        proposal,
+        status: "skipped",
+        reason: "No fixer is registered for this rule",
+      });
+
+      continue;
+    }
+
+    const source = await readFile(proposal.file, "utf8");
+    const candidate = fixer.apply(source, proposal);
+
+    if (candidate === null) {
+      results.push({
+        proposal,
+        status: "skipped",
+        reason: "The line no longer matches a safe fix",
+      });
+
+      continue;
+    }
+
+    const before = summarize(
+      await runRules([proposal.file], { disabledRules })
+    );
+
+    const backupPath = await saveBackup(
+      root,
+      proposal.file,
+      attempt
+    );
+
+    await writeFile(proposal.file, candidate, "utf8");
+
+    const after = summarize(
+      await runRules([proposal.file], { disabledRules })
+    );
+
+    const key = `${proposal.rule}|${proposal.message}`;
+
+    if (isExpectedAfterFix(before, after, key)) {
+      results.push({
+        proposal,
+        status: "applied",
+        backupPath,
+      });
+    } else {
+      await restoreBackup(proposal.file, backupPath);
+
+      results.push({
+        proposal,
+        status: "rolled back",
+        backupPath,
+        reason:
+          "The change did not fix the issue cleanly, so the original was restored",
+      });
+    }
+  }
+
+  return {
+    results,
+    gitignoreUpdated: changed,
+  };
+}

package/src/setup.js

@@ -0,0 +1,114 @@
+import {
+  writeFile,
+  readFile,
+  appendFile,
+} from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { rules } from "../rules/index.js";
+
+export const CONFIG_NAME = "vhite.config.json";
+
+export function canAskQuestions() {
+  return Boolean(
+    process.stdin.isTTY &&
+    process.stdout.isTTY &&
+    !process.env.CI
+  );
+}
+
+async function ensureConfigIgnored(root) {
+  const gitignorePath = join(root, ".gitignore");
+  const entry = CONFIG_NAME;
+
+  let contents = "";
+
+  try {
+    contents = await readFile(gitignorePath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+
+  const alreadyIgnored = contents
+    .split(/\r?\n/)
+    .some((line) => line.trim() === entry);
+
+  if (alreadyIgnored) return;
+
+  const prefix =
+    contents.length > 0 && !contents.endsWith("\n")
+      ? "\n"
+      : "";
+
+  await appendFile(
+    gitignorePath,
+    `${prefix}${entry}\n`,
+    "utf8"
+  );
+}
+
+export async function runFirstTimeSetup(root) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    console.log(
+      `No ${CONFIG_NAME} found. Choose which rules to turn off.`
+    );
+
+    rules.forEach((rule, index) => {
+      console.log(
+        `  ${index + 1}. ${rule.name}: ${rule.description}`
+      );
+    });
+
+    console.log("");
+
+    const answer = (
+      await rl.question(
+        "Enter rule numbers separated by commas (for example 1,3), or press Enter to use all rules: "
+      )
+    ).trim();
+
+    const disabled = new Set();
+
+    if (answer !== "") {
+      for (const part of answer.split(",")) {
+        const entry = part.trim();
+        if (entry === "") continue;
+
+        const number = Number(entry);
+
+        if (
+          Number.isInteger(number) &&
+          number >= 1 &&
+          number <= rules.length
+        ) {
+          disabled.add(rules[number - 1].name);
+        } else {
+          console.log(
+            `Ignored "${entry}": not a rule number`
+          );
+        }
+      }
+    }
+
+    const config = {
+      disabledRules: [...disabled],
+    };
+
+    await writeFile(
+      join(root, CONFIG_NAME),
+      JSON.stringify(config, null, 2) + "\n",
+      "utf8"
+    );
+
+    await ensureConfigIgnored(root);
+
+    console.log(`Saved ${CONFIG_NAME}`);
+  } finally {
+    rl.close();
+  }
+}