lintlane 2.5.0 → 4.0.0

package/bin/commit-cli.mjs

@@ -1,148 +1,62 @@
-// `lintlane commit` — guided Conventional Commit (Commitizen's `cz commit`).
+// `lintlane commit` — guided Conventional Commit, run by Commitizen.
 //
-//   lintlane commit [options] [-- <git commit args>]
+//   lintlane commit [commitizen options] [-- <git commit args>]
 //
-//   --dry-run                      show the message, don't commit
-//   --write-message-to-file <file> write the message to a file
-//   --retry / --no-retry           reuse the last message after a failed commit / force a new prompt
-//   -l, --message-length-limit <n> max header length (0 = no limit)
-//   -- <args>                      everything after -- goes to `git commit`
-//                                  (e.g. `-- -a -S` to stage all and sign, `-- -n` to skip hooks)
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { parseArgs } from "node:util";
-import { loadCommitConfig } from "./commit-config.mjs";
-import { promptCommit } from "./commit-prompt.mjs";
+// Commitizen's own flags work as-is: --dry-run, --retry, -a, -S, ... and
+// everything after -- goes to `git commit` (e.g. `-- -n` to skip hooks).
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTool, runInherit } from "./proc.mjs";
 
 export const COMMIT_HELP = `Usage: lintlane commit [options] [-- <git commit args>]
 
-Asks a few questions and creates a Conventional Commit. Alias: lintlane c
+Asks a few questions and creates a Conventional Commit (Commitizen). Alias: lintlane c
 
-Options:
-  --dry-run                       Show the message without committing
-  --write-message-to-file <file>  Write the message to a file (combine with --dry-run)
-  --retry                         Reuse the last message after a failed commit
-  --no-retry                      Always ask, even if retryAfterFailure is set
-  -l, --message-length-limit <n>  Maximum header length (0 = no limit)
+Options (passed to Commitizen):
+  --dry-run         Show what would happen without committing
+  --retry           Reuse the last commit message after a failed commit
+  -a, --all         Stage all tracked changes first
+  -S, --signoff     Sign off the commit
 
 Anything after -- is passed to git commit:
-  lintlane commit -- -a -S       stage all tracked changes and sign the commit
-  lintlane commit -- -n          skip git hooks
-  lintlane commit -- -s          add a Signed-off-by line
+  lintlane commit -- -S       sign the commit
+  lintlane commit -- -n       skip git hooks
+
+Needs "config.commitizen.path" in package.json; \`lintlane init\` adds it.
 `;
 
 const err = (text) => process.stderr.write(`${text}\n`);
 
-function git(args, cwd, extra = {}) {
-  return spawnSync("git", args, { cwd, encoding: "utf8", ...extra });
+function hasAdapter(cwd) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+    return Boolean(pkg?.config?.commitizen?.path) || existsSync(join(cwd, ".czrc"));
+  } catch {
+    return false;
+  }
 }
 
 export async function runCommit({ argv, gitArgs = [], cwd = process.cwd() }) {
-  let values;
-  try {
-    ({ values } = parseArgs({
-      args: argv,
-      options: {
-        "dry-run": { type: "boolean" },
-        "write-message-to-file": { type: "string" },
-        retry: { type: "boolean" },
-        "no-retry": { type: "boolean" },
-        "message-length-limit": { type: "string", short: "l" },
-        help: { type: "boolean", short: "h" },
-      },
-    }));
-  } catch (error) {
-    err(`✘ ${error.message}\n\n${COMMIT_HELP}`);
-    return 2;
-  }
-  if (values.help) {
+  if (argv.includes("-h") || argv.includes("--help")) {
     process.stdout.write(COMMIT_HELP);
     return 0;
   }
-  if (values.retry && values["no-retry"]) {
-    err("✘ Use either --retry or --no-retry, not both.");
-    return 2;
-  }
-
-  const inRepo = git(["rev-parse", "--git-dir"], cwd);
-  if (inRepo.status !== 0) {
-    err("✘ Not inside a git repository.");
+  const cz = resolveTool("commitizen", "git-cz");
+  if (!cz) {
+    err("✘ Commitizen isn't installed. Reinstall lintlane with your package manager.");
     return 1;
   }
-
-  const config = loadCommitConfig(cwd);
-  const options = {
-    ...config,
-    messageLengthLimit: values["message-length-limit"] ?? config.messageLengthLimit,
-  };
-  const dryRun = Boolean(values["dry-run"]);
-
-  // `-- -a` makes git stage tracked changes itself, so "nothing staged" is fine then.
-  const stagesItself = gitArgs.some((a) => a === "-a" || a === "--all");
-  if (!dryRun && !stagesItself && git(["diff", "--cached", "--quiet"], cwd).status === 0) {
+  if (!hasAdapter(cwd)) {
     err(
-      "✘ Nothing is staged. Stage your changes first (git add <files>), or use: lintlane commit -- -a",
+      '✘ Commitizen has no adapter configured. Run `lintlane init`, or add to package.json:\n  "config": { "commitizen": { "path": "lintlane/presets/commitizen.cjs" } }',
     );
     return 1;
   }
-
-  const savedPath = resolve(
-    cwd,
-    git(["rev-parse", "--git-path", "lintlane-commit-msg"], cwd).stdout.trim(),
-  );
-  const saved = existsSync(savedPath) ? readFileSync(savedPath, "utf8") : null;
-
-  let message;
-  const autoRetry = Boolean(config.retryAfterFailure) && !values["no-retry"] && saved !== null;
-  if (values.retry || autoRetry) {
-    if (saved === null) {
-      err("✘ There's no previous commit message to retry.");
-      return 1;
-    }
-    message = saved;
-    err("↻ Reusing your last commit message:\n");
-    err(message.replace(/^/gm, "  "));
-    err("");
-  } else {
-    try {
-      message = await promptCommit({ options });
-    } catch {
-      err("\n✘ Commit cancelled.");
-      return 1;
-    }
-    if (message === null) {
-      err("\n✘ Commit cancelled.");
-      return 1;
-    }
-  }
-
-  if (values["write-message-to-file"]) {
-    const target = resolve(cwd, values["write-message-to-file"]);
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, `${message}\n`);
-  }
-  if (dryRun) {
-    process.stdout.write(`${message}\n`);
-    return 0;
-  }
-
-  // Keep the message until the commit actually succeeds, so a failing
-  // pre-commit hook doesn't throw away your answers.
-  mkdirSync(dirname(savedPath), { recursive: true });
-  writeFileSync(savedPath, message);
-
-  const result = spawnSync("git", ["commit", "-F", "-", ...gitArgs], {
-    cwd,
-    input: message,
-    stdio: ["pipe", "inherit", "inherit"],
-  });
-  if (result.status === 0) {
-    rmSync(savedPath, { force: true });
-    return 0;
-  }
-  err(
-    "\n✘ git commit failed. Your message was saved — fix the problem, then run:  lintlane commit --retry",
+  return runInherit(
+    cz[0],
+    [...cz.slice(1), ...argv, ...(gitArgs.length ? ["--", ...gitArgs] : [])],
+    {
+      cwd,
+    },
   );
-  return result.status ?? 1;
 }

package/bin/doctor.mjs

@@ -0,0 +1,328 @@
+// `lintlane doctor` — diagnose the setup. Read-only: it never changes anything.
+//
+// Each finding is { id, status: "pass" | "warn" | "fail", message, fix? }.
+// "fail" means something is broken; "warn" means something is missing or out of
+// date but nothing is wrong yet. The exit code is 1 only when there is a fail.
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { resolveChecks } from "./checks.mjs";
+import { binPath, resolveBiome, resolveTool, runProcess } from "./proc.mjs";
+import {
+  ciCommand,
+  classifyHook,
+  detectPackageManager,
+  hasCommitlintConfig,
+  hasLintStagedConfig,
+  installCommand,
+} from "./project.mjs";
+
+const HOOK_NAMES = ["pre-commit", "commit-msg", "prepare-commit-msg", "pre-push"];
+
+function major(version) {
+  return Number(String(version).replace(/^v/, "").split(".")[0]);
+}
+
+export async function runDoctor({ cwd, kitDir }) {
+  const findings = [];
+  const add = (id, status, message, fix) =>
+    findings.push({ id, status, message, ...(fix ? { fix } : {}) });
+
+  const kitPkg = JSON.parse(readFileSync(join(kitDir, "package.json"), "utf8"));
+  const minNode = major(String(kitPkg.engines?.node ?? ">=22").replace(/[^\d.]/g, ""));
+  if (major(process.version) >= minNode) add("node", "pass", `Node.js ${process.version}`);
+  else {
+    add(
+      "node",
+      "fail",
+      `Node.js ${process.version}; lintlane needs ${kitPkg.engines.node}`,
+      "Upgrade Node.js.",
+    );
+  }
+
+  const pkgPath = join(cwd, "package.json");
+  let pkg = null;
+  if (!existsSync(pkgPath)) {
+    add(
+      "package-json",
+      "fail",
+      "No package.json in this directory",
+      "Run this from your project root.",
+    );
+  } else {
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      add("package-json", "pass", "package.json is valid");
+    } catch (error) {
+      add("package-json", "fail", `package.json is not valid JSON: ${error.message}`);
+    }
+  }
+  if (!pkg) return finish(findings, kitPkg);
+
+  const pm = detectPackageManager(cwd, pkg);
+  const install = (name) => installCommand(pm.name, [name]).join(" ");
+  add("package-manager", "pass", `${pm.name} (from ${pm.source})`);
+
+  const git = await runProcess("git", ["rev-parse", "--show-toplevel"], { cwd });
+  const inRepo = git.code === 0;
+  if (inRepo) add("git", "pass", "Inside a git repository");
+  else add("git", "warn", "Not a git repository, so hooks can't be installed", "Run `git init`.");
+
+  // Biome
+  const biome = resolveBiome(cwd);
+  if (!biome) {
+    add("biome", "fail", "Biome isn't installed", `Install it: ${install("@biomejs/biome")}`);
+  } else {
+    const version = await runProcess(biome[0], [...biome.slice(1), "--version"], { cwd });
+    const local = existsSync(binPath(cwd, "biome"));
+    if (version.code !== 0)
+      add("biome", "fail", "Biome is installed but doesn't run", "Reinstall dependencies.");
+    else if (!local) {
+      add(
+        "biome",
+        "warn",
+        "Biome isn't installed in this project; using the copy next to lintlane, which lint-staged can't find",
+        `Install it: ${install("@biomejs/biome")}`,
+      );
+    } else
+      add(
+        "biome",
+        "pass",
+        `Biome ${version.stdout
+          .toString()
+          .trim()
+          .replace(/^Version:\s*/, "")}`,
+      );
+  }
+  if (existsSync(join(cwd, "biome.json")) || existsSync(join(cwd, "biome.jsonc"))) {
+    add("biome-config", "pass", "Biome config found");
+  } else {
+    add("biome-config", "warn", "No biome.json", "Run `lintlane init`.");
+  }
+
+  // lintlane itself
+  const localKit = join(cwd, "node_modules", "lintlane", "bin", "cli.mjs");
+  const isKitRepo = pkg.name === "lintlane";
+  if (existsSync(localKit) || isKitRepo)
+    add("lintlane-installed", "pass", "lintlane is installed in this project");
+  else
+    add(
+      "lintlane-installed",
+      "fail",
+      "lintlane isn't installed in this project",
+      `Install it: ${install("lintlane")}`,
+    );
+
+  // Bundled tools
+  for (const [pkgName, bin] of [
+    ["lint-staged"],
+    ["@commitlint/cli", "commitlint"],
+    ["commitizen", "git-cz"],
+  ]) {
+    add(
+      `tool:${pkgName}`,
+      resolveTool(pkgName, bin) ? "pass" : "fail",
+      resolveTool(pkgName, bin) ? `${pkgName} is available` : `${pkgName} can't be found`,
+      resolveTool(pkgName, bin) ? undefined : "Reinstall lintlane.",
+    );
+  }
+
+  // Git hooks
+  if (inRepo) {
+    const hooksPath = (
+      await runProcess("git", ["config", "--get", "core.hooksPath"], { cwd })
+    ).stdout
+      .toString()
+      .trim();
+    const huskyDir = join(cwd, ".husky");
+    const hasHooks = HOOK_NAMES.some((name) => existsSync(join(huskyDir, name)));
+    if (!hasHooks) {
+      add(
+        "hooks",
+        "warn",
+        "No .husky hooks found",
+        "Run `lintlane init` (or ignore if you opted out with --no-hooks).",
+      );
+    } else {
+      const huskyDep = pkg.devDependencies?.husky ?? pkg.dependencies?.husky;
+      if (!huskyDep)
+        add(
+          "husky",
+          "fail",
+          "Hooks exist but husky isn't a dependency",
+          `Install it: ${install("husky")}`,
+        );
+      else add("husky", "pass", `husky ${huskyDep}`);
+
+      if (/husky/.test(pkg.scripts?.prepare ?? ""))
+        add("prepare-script", "pass", '"prepare" script runs husky');
+      else
+        add(
+          "prepare-script",
+          "warn",
+          'No "prepare" script running husky, so teammates won\'t get hooks on install',
+          'Add "prepare": "husky".',
+        );
+
+      if (/(^|\/)\.husky(\/_)?$/.test(hooksPath))
+        add("hooks-path", "pass", `core.hooksPath = ${hooksPath}`);
+      else {
+        add(
+          "hooks-path",
+          "fail",
+          `git isn't using .husky (core.hooksPath = ${hooksPath || "unset"})`,
+          `Run: ${pm.name === "npm" ? "npx" : pm.name === "bun" ? "bunx" : `${pm.name} exec`} husky`,
+        );
+      }
+
+      for (const name of HOOK_NAMES) {
+        const hookPath = join(huskyDir, name);
+        const templatePath = join(kitDir, "templates", name);
+        if (!existsSync(hookPath)) {
+          if (name === "pre-commit")
+            add(`hook:${name}`, "fail", ".husky/pre-commit is missing", "Run `lintlane init`.");
+          else
+            add(
+              `hook:${name}`,
+              "warn",
+              `.husky/${name} is missing`,
+              "Run `lintlane init` (or ignore if you opted out with --no-commit-lint).",
+            );
+          continue;
+        }
+        const state = classifyHook(
+          name,
+          readFileSync(hookPath, "utf8"),
+          readFileSync(templatePath, "utf8"),
+        );
+        const executable = process.platform === "win32" || (statSync(hookPath).mode & 0o111) !== 0;
+        if (state === "legacy") {
+          add(
+            `hook:${name}`,
+            "fail",
+            `.husky/${name} is from an older lintlane and no longer does anything`,
+            "Run `lintlane init` to upgrade it.",
+          );
+        } else if (state === "stale" || state === "unsafe") {
+          add(
+            `hook:${name}`,
+            "fail",
+            `.husky/${name} calls files lintlane no longer ships`,
+            `Replace its contents with node_modules/lintlane/templates/${name}.`,
+          );
+        } else if (!executable) {
+          add(`hook:${name}`, "fail", `.husky/${name} isn't executable`, `chmod +x .husky/${name}`);
+        } else {
+          add(
+            `hook:${name}`,
+            "pass",
+            state === "current" ? `.husky/${name} is up to date` : `.husky/${name} is customized`,
+          );
+        }
+      }
+    }
+    if (existsSync(join(git.stdout.toString().trim(), ".git", "lintlane-backup"))) {
+      add(
+        "old-backup",
+        "warn",
+        "Leftover .git/lintlane-backup from lintlane < 4 (an interrupted old hook run)",
+        "Check its files for unsaved work, then delete the folder.",
+      );
+    }
+  }
+
+  // Staged files + commits
+  if (hasLintStagedConfig(cwd, pkg)) add("lint-staged-config", "pass", "lint-staged is configured");
+  else
+    add(
+      "lint-staged-config",
+      "warn",
+      "No lint-staged configuration; the pre-commit hook has nothing to run",
+      "Run `lintlane init`.",
+    );
+
+  if (hasCommitlintConfig(cwd, pkg)) add("commitlint-config", "pass", "commitlint is configured");
+  else
+    add(
+      "commitlint-config",
+      "warn",
+      "No commitlint configuration; commit messages aren't validated",
+      "Run `lintlane init`.",
+    );
+
+  const czPath = pkg.config?.commitizen?.path;
+  if (czPath) add("commitizen-config", "pass", `Commitizen adapter: ${czPath}`);
+  else
+    add(
+      "commitizen-config",
+      "warn",
+      "No Commitizen adapter; `lintlane commit` can't prompt",
+      "Run `lintlane init`.",
+    );
+
+  // Checks + CI
+  if (biome) {
+    const { steps, problems } = resolveChecks({ cwd, biome, pmName: pm.name, pkg });
+    for (const problem of problems) add("checks-config", "warn", problem);
+    if (problems.length === 0) {
+      add(
+        "checks",
+        "pass",
+        `Checks: ${steps
+          .filter((s) => s.defaultOn)
+          .map((s) => s.id)
+          .join(", ")}`,
+      );
+    }
+    const ciPath = join(cwd, ".github", "workflows", "biome.yml");
+    if (existsSync(ciPath)) {
+      const workflow = readFileSync(ciPath, "utf8");
+      const missing = steps
+        .filter((step) => step.ci)
+        .map((step) => ciCommand(pm.name, step))
+        .filter((command) => command && !workflow.includes(command));
+      if (missing.length === 0)
+        add("ci", "pass", ".github/workflows/biome.yml matches your checks");
+      else
+        add(
+          "ci",
+          "warn",
+          `CI workflow doesn't run: ${missing.join(", ")}`,
+          "Add those steps, or turn the check off in package.json under lintlane.checks.",
+        );
+    } else {
+      add(
+        "ci",
+        "warn",
+        "No .github/workflows/biome.yml",
+        "Run `lintlane init` (or ignore if you opted out with --no-ci).",
+      );
+    }
+  }
+
+  return finish(findings, kitPkg);
+}
+
+function finish(findings, kitPkg) {
+  return {
+    ok: !findings.some((finding) => finding.status === "fail"),
+    version: kitPkg.version,
+    findings,
+  };
+}
+
+const ICONS = { pass: "✔", warn: "!", fail: "✘" };
+
+export function formatReport(report) {
+  const lines = [`lintlane doctor (v${report.version})`, ""];
+  for (const f of report.findings) {
+    lines.push(`${ICONS[f.status]} ${f.message}`);
+    if (f.fix && f.status !== "pass") lines.push(`    → ${f.fix}`);
+  }
+  const fails = report.findings.filter((f) => f.status === "fail").length;
+  const warns = report.findings.filter((f) => f.status === "warn").length;
+  lines.push(
+    "",
+    fails || warns ? `${fails} problem(s), ${warns} warning(s).` : "Everything looks good.",
+  );
+  return lines.join("\n");
+}

package/bin/hook.mjs

@@ -0,0 +1,156 @@
+// Git hook entry points, run as `lintlane hook <name> [git args]` from the
+// .husky/ scripts. Each one hands the real work to a proven tool:
+//
+//   pre-commit          lint-staged   (safe with partially staged files; runs Biome)
+//   commit-msg          commitlint    (validates the message)
+//   prepare-commit-msg  commitizen    (guided prompt on a plain `git commit`)
+//   pre-push            commitlint    (checks every commit about to be pushed)
+import { spawnSync } from "node:child_process";
+import { closeSync, openSync, readFileSync } from "node:fs";
+import { resolveTool, runInherit, runProcess } from "./proc.mjs";
+
+export const HOOKS = ["pre-commit", "commit-msg", "prepare-commit-msg", "pre-push"];
+
+const ZERO = /^0+$/;
+const err = (text) => process.stderr.write(`${text}\n`);
+
+function tool(pkg, bin) {
+  const argv = resolveTool(pkg, bin);
+  if (!argv) {
+    err(`lintlane: couldn't find ${pkg}. Reinstall lintlane with your package manager.`);
+  }
+  return argv;
+}
+
+async function gitText(args, cwd) {
+  const result = await runProcess("git", args, { cwd });
+  return result.code === 0 ? result.stdout.toString().trim() : null;
+}
+
+async function preCommit(cwd) {
+  const argv = tool("lint-staged");
+  if (!argv) return 1;
+  return runInherit(argv[0], argv.slice(1), { cwd });
+}
+
+async function commitMsg(cwd, [file]) {
+  if (!file) {
+    err("lintlane: commit-msg expects the path to the commit message file.");
+    return 2;
+  }
+  const argv = tool("@commitlint/cli", "commitlint");
+  if (!argv) return 1;
+  return runInherit(argv[0], [...argv.slice(1), "--edit", file, "--cwd", cwd], { cwd });
+}
+
+// A plain `git commit` (no -m, no template, not a merge or amend) gets the guided
+// prompt. Anything else, or no terminal to ask on, is left alone.
+function prepareCommitMsg(cwd, [file, source]) {
+  if (!file || source || process.env.CI || process.env.LINTLANE_NO_PROMPT) return 0;
+  if (process.platform === "win32") return 0;
+  const argv = tool("commitizen", "git-cz");
+  if (!argv) return 0;
+  let tty;
+  try {
+    tty = openSync("/dev/tty", "r"); // git runs hooks with stdin detached
+  } catch {
+    return 0; // GUI client, script: stay out of the way
+  }
+  try {
+    const result = spawnSync(argv[0], [...argv.slice(1), "--hook"], {
+      cwd,
+      stdio: [tty, "inherit", "inherit"],
+    });
+    return result.status ?? 1;
+  } finally {
+    closeSync(tty);
+  }
+}
+
+async function lintRange(argv, cwd, from, to) {
+  const result = await runProcess(
+    argv[0],
+    [...argv.slice(1), "--from", from, "--to", to, "--cwd", cwd],
+    {
+      cwd,
+    },
+  );
+  if (result.code !== 0) {
+    process.stderr.write(result.stderr);
+    process.stdout.write(result.stdout);
+  }
+  return result.code === 0;
+}
+
+async function lintMessage(argv, cwd, message) {
+  const result = await runProcess(argv[0], [...argv.slice(1), "--cwd", cwd], {
+    cwd,
+    input: message,
+  });
+  if (result.code !== 0) {
+    process.stderr.write(result.stderr);
+    process.stdout.write(result.stdout);
+  }
+  return result.code === 0;
+}
+
+// Safety net for commits that skipped commit-msg (--no-verify, a GUI client, a
+// clone without hooks). Never blocks when a range can't be inspected.
+async function prePush(cwd, [remote = "origin"], stdin) {
+  const argv = tool("@commitlint/cli", "commitlint");
+  if (!argv) return 1;
+  let bad = 0;
+  for (const line of stdin.split("\n")) {
+    const [localRef, localSha, , remoteSha] = line.trim().split(/\s+/);
+    if (!localRef || !localSha || ZERO.test(localSha) || localRef.startsWith("refs/tags/"))
+      continue;
+    if (!ZERO.test(remoteSha ?? "0")) {
+      if (!(await lintRange(argv, cwd, remoteSha, localSha))) bad++;
+      continue;
+    }
+    // New branch: every commit not already on a remote.
+    const listed = await gitText(
+      ["rev-list", "--reverse", localSha, "--not", `--remotes=${remote}`],
+      cwd,
+    );
+    const commits = listed ? listed.split("\n") : [];
+    if (commits.length === 0) continue;
+    if ((await gitText(["rev-parse", "--verify", "-q", `${commits[0]}^`], cwd)) !== null) {
+      if (!(await lintRange(argv, cwd, `${commits[0]}^`, localSha))) bad++;
+    } else {
+      for (const sha of commits) {
+        const message = await gitText(["log", "-1", "--format=%B", sha], cwd);
+        if (message !== null && !(await lintMessage(argv, cwd, message))) bad++;
+      }
+    }
+  }
+  if (bad > 0) {
+    err(
+      "\n✘ Push blocked: some commit messages don't follow Conventional Commits.\n" +
+        "  Reword them with `git rebase -i` (or `git commit --amend` for the latest), then push again.\n",
+    );
+    return 1;
+  }
+  return 0;
+}
+
+export async function runHook(name, args, cwd = process.cwd()) {
+  switch (name) {
+    case "pre-commit":
+      return preCommit(cwd);
+    case "commit-msg":
+      return commitMsg(cwd, args);
+    case "prepare-commit-msg":
+      return prepareCommitMsg(cwd, args);
+    case "pre-push": {
+      let stdin = "";
+      try {
+        stdin = readFileSync(0, "utf8");
+      } catch {}
+      return prePush(cwd, args, stdin);
+    }
+    default:
+      err(`lintlane: unknown hook "${name}". Known hooks: ${HOOKS.join(", ")}.`);
+      return 2;
+  }
+}