lintlane 3.0.1 → 4.0.0

package/bin/commit-prompt.mjs

@@ -1,110 +0,0 @@
-// Interactive "commit with steps" prompt (the Commitizen-style flow).
-// Plain Node, readline only — no dependencies.
-import { createInterface } from "node:readline/promises";
-import { buildMessage, resolveOptions } from "./commit-lint.mjs";
-
-const supportsColor = (stream) => stream.isTTY && !process.env.NO_COLOR;
-
-/**
- * Ask the questions and return the finished message, or null if the user
- * chose not to commit. Throws if the input ends (Ctrl+C / Ctrl+D).
- */
-export async function promptCommit({
-  input = process.stdin,
-  output = process.stderr,
-  options,
-} = {}) {
-  const { types: TYPES, maxHeader: MAX_HEADER } = resolveOptions(options);
-  const typeWidth = Math.max(...TYPES.map(([type]) => type.length));
-  const rl = createInterface({ input, output });
-  const c = supportsColor(output)
-    ? {
-        b: (s) => `\x1b[1m${s}\x1b[0m`,
-        d: (s) => `\x1b[2m${s}\x1b[0m`,
-        g: (s) => `\x1b[32m${s}\x1b[0m`,
-        r: (s) => `\x1b[31m${s}\x1b[0m`,
-      }
-    : { b: (s) => s, d: (s) => s, g: (s) => s, r: (s) => s };
-  const say = (text = "") => output.write(`${text}\n`);
-
-  // Queue incoming lines so input that arrives early (pasted or piped) isn't
-  // lost between questions, and so a closed input ends the prompt instead of
-  // leaving it waiting forever.
-  const lines = rl[Symbol.asyncIterator]();
-  const ask = async (question) => {
-    rl.setPrompt(question);
-    rl.prompt();
-    const { value, done } = await lines.next();
-    if (done) throw new Error("input closed");
-    return value.trim();
-  };
-
-  try {
-    say(c.b("\nCommit — step 1/7: type of change"));
-    TYPES.forEach(([type, description], i) => {
-      say(`  ${String(i + 1).padStart(2)}. ${c.g(type.padEnd(typeWidth))} ${c.d(description)}`);
-    });
-    let type;
-    while (!type) {
-      const answer = (await ask("Choose a type (number or name): ")).toLowerCase();
-      type = TYPES.find(([name], i) => name === answer || String(i + 1) === answer)?.[0];
-      if (!type) say(c.r("  Pick one of the listed types."));
-    }
-
-    say(c.b("\nStep 2/7: scope") + c.d("  (optional — the area you changed, e.g. auth, api, ui)"));
-    let scope = "";
-    for (;;) {
-      scope = await ask("Scope (Enter to skip): ");
-      if (!/[()]/.test(scope)) break;
-      say(c.r("  Scope can't contain parentheses."));
-    }
-
-    say(c.b("\nStep 3/7: subject") + c.d("  (short, imperative: “add login form”, no period)"));
-    let subject = "";
-    for (;;) {
-      subject = await ask("Subject: ");
-      const headerLength = `${type}${scope ? `(${scope})` : ""}: ${subject}`.length;
-      if (!subject) say(c.r("  The subject is required."));
-      else if (subject.endsWith(".")) say(c.r("  Remove the trailing period."));
-      else if (MAX_HEADER > 0 && headerLength > MAX_HEADER)
-        say(c.r(`  Too long (${headerLength}/${MAX_HEADER}). Shorten it.`));
-      else break;
-    }
-
-    say(c.b("\nStep 4/7: body") + c.d("  (optional — why, not what. Empty line to finish)"));
-    const bodyLines = [];
-    for (;;) {
-      const line = await ask(bodyLines.length === 0 ? "Body (Enter to skip): " : "  …: ");
-      if (line === "") break;
-      bodyLines.push(line);
-    }
-
-    say(c.b("\nStep 5/7: breaking change?"));
-    let breaking = "";
-    if ((await ask("Does this break existing behaviour? (y/N): ")).toLowerCase().startsWith("y")) {
-      while (!breaking) {
-        breaking = await ask("Describe what breaks and how to migrate: ");
-      }
-    }
-
-    say(c.b("\nStep 6/7: footer") + c.d("  (optional — issues this closes, e.g. “Closes #123”)"));
-    const footer = await ask("Footer (Enter to skip): ");
-
-    const message = buildMessage({
-      type,
-      scope,
-      subject,
-      body: bodyLines.join("\n"),
-      breaking,
-      footer,
-    });
-    say(c.b("\nStep 7/7: confirm"));
-    say(c.d("─".repeat(40)));
-    say(message);
-    say(c.d("─".repeat(40)));
-    const confirm = (await ask("Use this message? (Y/n): ")).toLowerCase();
-    return confirm === "" || confirm.startsWith("y") ? message : null;
-  } finally {
-    rl.close();
-  }
-}

package/bin/pre-commit.mjs

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// git `pre-commit` hook entry: formats and lints the staged files with Biome
-// without ever staging anything the developer didn't stage (see staged.mjs).
-//
-//   node pre-commit.mjs            run the checks (what the hook does)
-//   node pre-commit.mjs --restore  recover working files after an interrupted run
-import { resolveBiome, runProcess } from "./proc.mjs";
-import { restoreFromBackup, runStagedChecks, StaleBackupError } from "./staged.mjs";
-
-const out = (text) => process.stdout.write(text);
-const err = (text) => process.stderr.write(text);
-
-const top = await runProcess("git", ["rev-parse", "--show-toplevel"]);
-if (top.code !== 0) {
-  err("lintlane: not inside a git repository.\n");
-  process.exit(1);
-}
-const cwd = top.stdout.toString().trim();
-process.chdir(cwd);
-
-if (process.argv.includes("--restore")) {
-  const { restored, kept, found, backupDir } = await restoreFromBackup(cwd);
-  if (!found) out("lintlane: nothing to restore.\n");
-  for (const path of restored) out(`restored ${path}\n`);
-  for (const path of kept) err(`kept ${path}: it changed since the backup (see ${backupDir})\n`);
-  process.exit(kept.length > 0 ? 1 : 0);
-}
-
-const biome = resolveBiome(cwd);
-if (!biome) {
-  err("lintlane: Biome isn't installed. Run your package manager's install, then commit again.\n");
-  process.exit(1);
-}
-
-try {
-  const result = await runStagedChecks({
-    cwd,
-    biome,
-    colors: process.stderr.isTTY ? "force" : "off",
-    log: { out, err },
-  });
-  for (const warning of result.warnings) err(`lintlane: ${warning}\n`);
-  process.exit(result.ok ? 0 : 1);
-} catch (error) {
-  if (error instanceof StaleBackupError) {
-    err(
-      `\nlintlane: an earlier run was interrupted before it could restore your files.\n` +
-        `  Your working copies are saved in ${error.backupDir}\n` +
-        `  Put them back with:  node node_modules/lintlane/bin/pre-commit.mjs --restore\n\n`,
-    );
-  } else {
-    err(`lintlane: ${error.message}\n`);
-  }
-  process.exit(1);
-}

package/bin/pre-push-check.mjs

@@ -1,48 +0,0 @@
-// git `pre-push` hook entry: checks every commit that's about to be pushed.
-// This is the safety net for commits that skipped the commit-msg hook
-// (`git commit --no-verify`, a GUI client, a clone where hooks weren't installed).
-// Plain Node on purpose — see commit-lint.mjs.
-import { readFileSync } from "node:fs";
-import { describeInvalid, findInvalidCommits, listCommits } from "./check-commit.mjs";
-import { loadCommitConfig } from "./commit-config.mjs";
-
-const [remote = "origin"] = process.argv.slice(2);
-const ZERO = /^0+$/;
-
-let input = "";
-try {
-  input = readFileSync(0, "utf8");
-} catch {}
-
-const options = loadCommitConfig();
-const invalid = [];
-const seen = new Set();
-
-for (const line of input.split("\n")) {
-  const [localRef, localSha, , remoteSha] = line.trim().split(/\s+/);
-  if (!localRef || !localSha || ZERO.test(localSha)) continue; // deleting a branch
-  if (localRef.startsWith("refs/tags/")) continue;
-
-  // New branch: everything not already on a remote. Existing: just the new commits.
-  const logArgs = ZERO.test(remoteSha ?? "0")
-    ? [localSha, "--not", `--remotes=${remote}`]
-    : [`${remoteSha}..${localSha}`];
-  try {
-    for (const bad of findInvalidCommits(listCommits(logArgs), options)) {
-      if (!seen.has(bad.hash)) {
-        seen.add(bad.hash);
-        invalid.push(bad);
-      }
-    }
-  } catch {
-    // Can't inspect the range (e.g. the remote's commit isn't local). Don't block the push.
-  }
-}
-
-if (invalid.length > 0) {
-  process.stderr.write(
-    `\n✘ Push blocked: ${invalid.length} commit message(s) don't follow Conventional Commits:\n\n${describeInvalid(invalid)}\n\n` +
-      "  Reword them with `git rebase -i` (or `git commit --amend` for the latest), then push again.\n\n",
-  );
-  process.exit(1);
-}

package/bin/prepare-commit-msg.mjs

@@ -1,46 +0,0 @@
-// git `prepare-commit-msg` hook entry: when you run a plain `git commit` (no -m,
-// no template, not a merge), walk through the guided prompt and pre-fill the
-// message — the same flow as `lintlane commit`.
-// Plain Node on purpose — see commit-lint.mjs.
-import { closeSync, openSync, readFileSync, writeFileSync } from "node:fs";
-import { ReadStream } from "node:tty";
-import { loadCommitConfig } from "./commit-config.mjs";
-import { promptCommit } from "./commit-prompt.mjs";
-
-const [file, source] = process.argv.slice(2);
-
-// source is set when the message came from -m/-F, a template, a merge, a
-// squash, or an amend. Only a plain `git commit` leaves it empty.
-if (!file || source || process.env.CI || process.env.LINTLANE_NO_PROMPT) process.exit(0);
-
-// Git runs hooks with stdin detached; talk to the terminal directly. If there
-// isn't one (a GUI client, CI, a script), stay out of the way.
-let fd;
-try {
-  fd = openSync("/dev/tty", "r");
-} catch {
-  process.exit(0);
-}
-
-try {
-  const message = await promptCommit({
-    input: new ReadStream(fd),
-    output: process.stderr,
-    options: loadCommitConfig(),
-  });
-  if (message === null) {
-    process.stderr.write("\nCommit cancelled.\n");
-    process.exit(1);
-  }
-  const existing = readFileSync(file, "utf8");
-  writeFileSync(file, `${message}\n${existing}`);
-  // The open terminal handle would otherwise keep this process (and git) waiting.
-  process.exit(0);
-} catch {
-  process.stderr.write("\nCommit cancelled.\n");
-  process.exit(1);
-} finally {
-  try {
-    closeSync(fd);
-  } catch {}
-}

package/bin/staged.mjs

@@ -1,333 +0,0 @@
-// Run Biome on the files staged for commit without ever touching anything the
-// developer didn't stage.
-//
-// The old hook ran `biome check --write --staged` and then
-// `git update-index --again`. Biome rewrites files in the working tree (unstaged
-// hunks included) and `--again` re-stages whatever is in the working tree, so
-// unstaged hunks of partially staged files silently joined the commit.
-//
-// This module instead:
-//   1. reads the exact staged content (the index blob) of every staged file;
-//   2. for files that also have unstaged changes, saves the developer's working
-//      copy to a backup and temporarily makes the working file equal the staged
-//      content, so Biome sees exactly what will be committed;
-//   3. runs Biome on the real files (same ignore rules, config and exit codes
-//      as before);
-//   4. on any failure, puts every file back byte for byte; the index is never
-//      touched;
-//   5. on success, writes the fixed content into the index entry of each staged
-//      path (git hash-object + git update-index --index-info; never `git add`),
-//      and merges Biome's changes back into the developer's working copy with a
-//      three-way merge, so their unstaged hunks survive. If the merge would
-//      conflict, the working copy is left exactly as the developer wrote it.
-//
-// Plain Node (no Bun APIs, no dependencies): this runs on every teammate's machine.
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { runProcess } from "./proc.mjs";
-
-const SKIPPED_MODES = new Set(["120000", "160000"]); // symlinks, submodules
-const BIOME_CHUNK = 100;
-const CONCURRENCY = 8;
-
-export class StaleBackupError extends Error {
-  constructor(backupDir) {
-    super(`An earlier lintlane run was interrupted. Your files are saved in ${backupDir}`);
-    this.name = "StaleBackupError";
-    this.backupDir = backupDir;
-  }
-}
-
-async function git(args, { cwd, input } = {}) {
-  const result = await runProcess("git", args, { cwd, input });
-  if (result.code !== 0) {
-    const detail =
-      result.stderr.toString().trim() || result.error?.message || `exit ${result.code}`;
-    throw new Error(`git ${args[0]} failed: ${detail}`);
-  }
-  return result.stdout;
-}
-
-async function mapLimit(items, limit, fn) {
-  const results = new Array(items.length);
-  let next = 0;
-  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    for (let i = next++; i < items.length; i = next++) results[i] = await fn(items[i], i);
-  });
-  await Promise.all(workers);
-  return results;
-}
-
-/**
- * Staged files that are added, copied or modified (not deleted, not symlinks or
- * submodules). Renames are reported as a delete plus an add, so the new path is
- * included and the old one is not.
- */
-export async function listStagedFiles(cwd) {
-  const out = await git(
-    ["diff", "--cached", "--raw", "-z", "--no-renames", "--no-abbrev", "--diff-filter=ACM"],
-    { cwd },
-  );
-  const parts = out.toString("utf8").split("\0");
-  const files = [];
-  for (let i = 0; i + 1 < parts.length; i += 2) {
-    const [, mode, , sha] = parts[i].slice(1).split(" ");
-    const path = parts[i + 1];
-    if (!SKIPPED_MODES.has(mode)) files.push({ path, mode, sha });
-  }
-  return files;
-}
-
-async function backupDirFor(cwd) {
-  const rel = (await git(["rev-parse", "--git-path", "lintlane-backup"], { cwd }))
-    .toString()
-    .trim();
-  return resolve(cwd, rel);
-}
-
-/** Three-way merge of Biome's changes into the developer's working copy. */
-async function mergeThreeWay({ base, ours, theirs }) {
-  const dir = await mkdtemp(join(tmpdir(), "lintlane-merge-"));
-  try {
-    await Promise.all([
-      writeFile(join(dir, "ours"), ours),
-      writeFile(join(dir, "base"), base),
-      writeFile(join(dir, "theirs"), theirs),
-    ]);
-    const result = await runProcess(
-      "git",
-      ["merge-file", "-p", "-L", "ours", "-L", "base", "-L", "theirs", "ours", "base", "theirs"],
-      { cwd: dir },
-    );
-    // Exit code = number of conflicts (0 = clean); anything else is an error.
-    return result.code === 0
-      ? { merged: result.stdout, conflict: false }
-      : { merged: null, conflict: true };
-  } finally {
-    await rm(dir, { recursive: true, force: true });
-  }
-}
-
-function readIfExists(path) {
-  try {
-    return readFileSync(path);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Put files back the way they were before the run. A file is only overwritten
- * if it still holds what *we* left in it (the staged content or Biome's output);
- * if the developer saved something else in the meantime, it is left alone and
- * reported, and the backup is kept.
- */
-function restoreOriginals(cwd, entries) {
-  const kept = [];
-  for (const entry of entries) {
-    const original = entry.kind === "partial" ? entry.working : entry.blob;
-    const abs = join(cwd, entry.path);
-    const current = readIfExists(abs);
-    if (current?.equals(original)) continue;
-    const ours = [entry.blob, entry.after].filter(Boolean);
-    if (current === null || ours.some((buffer) => buffer.equals(current))) {
-      writeFileSync(abs, original);
-    } else {
-      kept.push(entry.path);
-    }
-  }
-  return kept;
-}
-
-/**
- * Check and fix the staged files. Resolves with { ok, changed, skipped, warnings }.
- * `biome` is an argv prefix (see resolveBiome). `log` receives user-facing text.
- */
-export async function runStagedChecks({ cwd, biome, log = {}, colors = "off" }) {
-  const say = log.out ?? (() => {});
-  const complain = log.err ?? (() => {});
-  const result = { ok: true, changed: [], skipped: [], warnings: [] };
-
-  const staged = await listStagedFiles(cwd);
-  if (staged.length === 0) return result;
-
-  const backupDir = await backupDirFor(cwd);
-  if (existsSync(backupDir) && readdirSync(backupDir).length > 0) {
-    throw new StaleBackupError(backupDir);
-  }
-
-  // 1. Snapshot the exact staged content and the working copy of every file.
-  const entries = [];
-  await mapLimit(staged, CONCURRENCY, async (file) => {
-    const blob = await git(["cat-file", "blob", file.sha], { cwd });
-    const working = readIfExists(join(cwd, file.path));
-    if (working === null) {
-      result.skipped.push(file.path); // deleted in the working tree: leave the index alone
-      return;
-    }
-    const kind = working.equals(blob) ? "clean" : "partial";
-    entries.push({ ...file, blob, working, kind, after: null });
-  });
-  entries.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-  if (entries.length === 0) return result;
-
-  // 2. Make the working copy of partially staged files equal the staged content,
-  //    after saving the developer's version somewhere durable.
-  const partial = entries.filter((entry) => entry.kind === "partial");
-  if (partial.length > 0) {
-    mkdirSync(backupDir, { recursive: true });
-    writeFileSync(
-      join(backupDir, "manifest.json"),
-      JSON.stringify(
-        {
-          version: 1,
-          createdAt: new Date().toISOString(),
-          files: partial.map((entry, i) => ({ id: i, path: entry.path, blob: entry.sha })),
-        },
-        null,
-        2,
-      ),
-    );
-    for (const [i, entry] of partial.entries()) {
-      writeFileSync(join(backupDir, String(i)), entry.working);
-    }
-  }
-
-  let finished = false;
-  const onSignal = (signal) => {
-    if (finished) return;
-    restoreOriginals(cwd, entries);
-    rmSync(backupDir, { recursive: true, force: true });
-    process.exit(signal === "SIGINT" ? 130 : 143);
-  };
-  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
-  for (const signal of signals) process.on(signal, onSignal);
-
-  try {
-    for (const entry of partial) writeFileSync(join(cwd, entry.path), entry.blob);
-
-    // 3. Run Biome on the real files, exactly as the old hook did.
-    const paths = entries.map((entry) =>
-      entry.path.startsWith("-") ? `./${entry.path}` : entry.path,
-    );
-    let biomeOk = true;
-    for (let i = 0; i < paths.length; i += BIOME_CHUNK) {
-      const run = await runProcess(
-        biome[0],
-        [
-          ...biome.slice(1),
-          "check",
-          "--write",
-          "--no-errors-on-unmatched",
-          "--files-ignore-unknown=true",
-          `--colors=${colors}`,
-          ...paths.slice(i, i + BIOME_CHUNK),
-        ],
-        { cwd },
-      );
-      if (run.error) {
-        complain(`lintlane: couldn't run Biome: ${run.error.message}\n`);
-        biomeOk = false;
-      } else {
-        if (run.stdout.length) say(run.stdout.toString());
-        if (run.stderr.length) complain(run.stderr.toString());
-        if (run.code !== 0) biomeOk = false;
-      }
-    }
-    for (const entry of entries) entry.after = readIfExists(join(cwd, entry.path));
-
-    // 4. Failure: put everything back. The index was never touched.
-    if (!biomeOk) {
-      const kept = restoreOriginals(cwd, entries);
-      result.ok = false;
-      result.warnings.push(
-        ...kept.map((path) => `${path} changed while the hook ran; left as saved`),
-      );
-      if (kept.length === 0) rmSync(backupDir, { recursive: true, force: true });
-      return result;
-    }
-
-    // 5. Success: record Biome's changes in the index, entry by entry...
-    const changed = entries.filter((entry) => entry.after && !entry.after.equals(entry.blob));
-    if (changed.length > 0) {
-      const shas = await mapLimit(changed, CONCURRENCY, async (entry) =>
-        (await git(["hash-object", "-w", "--no-filters", "--stdin"], { cwd, input: entry.after }))
-          .toString()
-          .trim(),
-      );
-      const records = changed
-        .map((entry, i) => `${entry.mode} ${shas[i]} 0\t${entry.path}\0`)
-        .join("");
-      await git(["update-index", "-z", "--index-info"], { cwd, input: Buffer.from(records) });
-      result.changed = changed.map((entry) => entry.path);
-    }
-
-    // ...and bring the developer's working copy of partially staged files up to
-    // date without losing their unstaged edits.
-    const kept = [];
-    for (const entry of partial) {
-      const abs = join(cwd, entry.path);
-      const current = readIfExists(abs);
-      if (current === null || !(entry.after ?? entry.blob).equals(current)) {
-        kept.push(entry.path); // changed under us; never overwrite
-        continue;
-      }
-      let next = entry.working;
-      if (entry.after && !entry.after.equals(entry.blob)) {
-        const { merged, conflict } = await mergeThreeWay({
-          base: entry.blob,
-          ours: entry.working,
-          theirs: entry.after,
-        });
-        if (!conflict) next = merged;
-        else
-          result.warnings.push(
-            `${entry.path}: your unstaged edits overlap the formatting changes; left as you wrote it`,
-          );
-      }
-      writeFileSync(abs, next);
-    }
-    result.warnings.push(
-      ...kept.map((path) => `${path} changed while the hook ran; left as saved`),
-    );
-    if (kept.length === 0) rmSync(backupDir, { recursive: true, force: true });
-    return result;
-  } catch (error) {
-    restoreOriginals(cwd, entries);
-    rmSync(backupDir, { recursive: true, force: true });
-    throw error;
-  } finally {
-    finished = true;
-    for (const signal of signals) process.removeListener(signal, onSignal);
-  }
-}
-
-/**
- * Recovery for a run that was killed before it could clean up (SIGKILL, power
- * loss): put the saved working copies back, unless the file changed since.
- */
-export async function restoreFromBackup(cwd) {
-  const backupDir = await backupDirFor(cwd);
-  const manifestPath = join(backupDir, "manifest.json");
-  if (!existsSync(manifestPath)) return { restored: [], kept: [], found: false };
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  const restored = [];
-  const kept = [];
-  for (const file of manifest.files) {
-    const abs = join(cwd, file.path);
-    const saved = readFileSync(join(backupDir, String(file.id)));
-    const blob = await git(["cat-file", "blob", file.blob], { cwd });
-    const current = readIfExists(abs);
-    // Still holding the staged content we swapped in (or already gone): safe to restore.
-    if (current === null || current.equals(blob) || current.equals(saved)) {
-      writeFileSync(abs, saved);
-      restored.push(file.path);
-    } else {
-      kept.push(file.path);
-    }
-  }
-  if (kept.length === 0) rmSync(backupDir, { recursive: true, force: true });
-  return { restored, kept, found: true, backupDir };
-}