lintlane 2.5.0 → 3.0.1

package/bin/ci.mjs

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { binPath, spawnPrepared } from "./proc.mjs";
 
 const MAX_LOG_CHARS = 2_000_000;
 
@@ -30,6 +31,7 @@ function firstScript(scripts, names) {
  * and the browser only ever sends step ids back — never command lines.
  */
 export function detectCiSteps({ cwd, biome, pmName, pkg }) {
+  // `biome` is an argv prefix: [path] or [node, script] (see resolveBiome).
   const scripts = pkg?.scripts ?? {};
   const run = RUN_SCRIPT[pmName] ?? RUN_SCRIPT.npm;
   const steps = [];
@@ -45,7 +47,7 @@ export function detectCiSteps({ cwd, biome, pmName, pkg }) {
   steps.push({
     id: "biome",
     label: "Biome CI (lint + format)",
-    cmd: [biome, "ci", "--colors=off", "."],
+    cmd: [...biome, "ci", "--colors=off", "."],
     display: "biome ci .",
     defaultOn: true,
     note: "The same check the GitHub workflow runs.",
@@ -59,14 +61,11 @@ export function detectCiSteps({ cwd, biome, pmName, pkg }) {
       cmd: run(typecheck),
       defaultOn: true,
     });
-  } else if (
-    existsSync(join(cwd, "tsconfig.json")) &&
-    existsSync(join(cwd, "node_modules", ".bin", "tsc"))
-  ) {
+  } else if (existsSync(`${cwd}/tsconfig.json`) && existsSync(binPath(cwd, "tsc"))) {
     steps.push({
       id: "typecheck",
       label: "Typecheck",
-      cmd: [join(cwd, "node_modules", ".bin", "tsc"), "--noEmit"],
+      cmd: [binPath(cwd, "tsc"), "--noEmit"],
       display: "tsc --noEmit",
       defaultOn: true,
     });
@@ -83,80 +82,87 @@ export function detectCiSteps({ cwd, biome, pmName, pkg }) {
   return steps.map((step) => ({ ...step, display: step.display ?? step.cmd.join(" ") }));
 }
 
+// Kill the step and everything it started (a build tool's child processes too).
+function killTree(child) {
+  if (!child || child.exitCode !== null) return;
+  try {
+    if (process.platform === "win32") child.kill();
+    else process.kill(-child.pid, "SIGTERM");
+  } catch {
+    try {
+      child.kill();
+    } catch {}
+  }
+}
+
 /**
- * Run steps one after another and stream NDJSON events:
+ * Run steps one after another, reporting events through `send`:
  *   start / log / end / skip / done
- * Closing the response (the browser's Stop button) kills the running process.
+ * Aborting `signal` (the browser's Stop button, or the page closing) kills the
+ * running step. Resolves when the run is over; never rejects.
  */
-export function ciStream({ cwd, steps, stopOnFail, release }) {
-  const encoder = new TextEncoder();
-  let proc = null;
-  let cancelled = false;
-
-  return new ReadableStream({
-    async start(controller) {
-      const send = (event) => {
-        if (!cancelled) controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
-      };
-      let failed = false;
-
-      try {
-        for (const step of steps) {
-          if (cancelled) break;
-          if (failed && stopOnFail) {
-            send({ type: "skip", id: step.id });
-            continue;
-          }
+export async function runCiSteps({ cwd, steps, stopOnFail, send, signal }) {
+  let child = null;
+  const onAbort = () => killTree(child);
+  signal?.addEventListener("abort", onAbort);
+  let failed = false;
+
+  try {
+    for (const step of steps) {
+      if (signal?.aborted) return;
+      if (failed && stopOnFail) {
+        send({ type: "skip", id: step.id });
+        continue;
+      }
 
-          send({ type: "start", id: step.id });
-          const t0 = performance.now();
-          let code = 1;
-          let sent = 0;
-          let truncated = false;
-
-          const pump = async (readable) => {
-            const decoder = new TextDecoder();
-            for await (const chunk of readable) {
-              const text = decoder.decode(chunk, { stream: true });
-              if (sent < MAX_LOG_CHARS) {
-                sent += text.length;
-                send({ type: "log", id: step.id, text });
-              } else if (!truncated) {
-                truncated = true;
-                send({ type: "log", id: step.id, text: "\n… output truncated …\n" });
-              }
-            }
-          };
-
-          try {
-            proc = Bun.spawn(step.cmd, {
-              cwd,
-              env: { ...process.env, CI: "true", NO_COLOR: "1", FORCE_COLOR: "0" },
-              stdin: "ignore",
-              stdout: "pipe",
-              stderr: "pipe",
-            });
-            await Promise.all([pump(proc.stdout), pump(proc.stderr)]);
-            code = await proc.exited;
-          } catch (error) {
-            send({ type: "log", id: step.id, text: `\n${error.message}\n` });
-            code = 127;
+      send({ type: "start", id: step.id });
+      const t0 = performance.now();
+      let sent = 0;
+      let truncated = false;
+
+      const pump = (stream) => {
+        const decoder = new StringDecoder("utf8");
+        stream.on("data", (chunk) => {
+          const text = decoder.write(chunk);
+          if (sent < MAX_LOG_CHARS) {
+            sent += text.length;
+            send({ type: "log", id: step.id, text });
+          } else if (!truncated) {
+            truncated = true;
+            send({ type: "log", id: step.id, text: "\n… output truncated …\n" });
           }
-          proc = null;
+        });
+      };
 
-          if (cancelled) break;
-          if (code !== 0) failed = true;
-          send({ type: "end", id: step.id, code, ms: Math.round(performance.now() - t0) });
+      const code = await new Promise((resolve) => {
+        try {
+          child = spawnPrepared(step.cmd[0], step.cmd.slice(1), {
+            cwd,
+            env: { ...process.env, CI: "true", NO_COLOR: "1", FORCE_COLOR: "0" },
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: process.platform !== "win32", // own process group, so Stop can kill the tree
+          });
+        } catch (error) {
+          send({ type: "log", id: step.id, text: `\n${error.message}\n` });
+          resolve(127);
+          return;
         }
-        send({ type: "done" });
-      } finally {
-        release();
-        if (!cancelled) controller.close();
-      }
-    },
-    cancel() {
-      cancelled = true;
-      proc?.kill();
-    },
-  });
+        pump(child.stdout);
+        pump(child.stderr);
+        child.on("error", (error) => {
+          send({ type: "log", id: step.id, text: `\n${error.message}\n` });
+          resolve(127);
+        });
+        child.on("close", (exitCode, killedBy) => resolve(exitCode ?? (killedBy ? 143 : 1)));
+      });
+      child = null;
+
+      if (signal?.aborted) return;
+      if (code !== 0) failed = true;
+      send({ type: "end", id: step.id, code, ms: Math.round(performance.now() - t0) });
+    }
+    send({ type: "done" });
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
 }

package/bin/cli.mjs

@@ -1,68 +1,27 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
-import { $ } from "bun";
-
-const KIT_DIR = join(import.meta.dir, "..");
-const KIT_PKG = await Bun.file(join(KIT_DIR, "package.json")).json();
+import { binPath, resolveBiome, runInherit, runProcess } from "./proc.mjs";
+import {
+  detectPackageManager,
+  detectPreset,
+  hasUnsafeRestaging,
+  installCommand,
+  isLegacyPreCommit,
+  PRESET_PATHS,
+  renderWorkflow,
+  runnerCommand,
+} from "./project.mjs";
+
+const KIT_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+const readJson = async (path) => JSON.parse(await readFile(path, "utf8"));
+const KIT_PKG = await readJson(join(KIT_DIR, "package.json"));
 const KIT_NAME = KIT_PKG.name;
 const KIT_VERSION = KIT_PKG.version;
-
-const PRESET_PATHS = {
-  base: "biome",
-  strict: "biome/strict",
-  next: "biome/next",
-};
-
-const PACKAGE_MANAGERS = {
-  bun: {
-    lockfile: "bun.lock",
-    install: (pkgs) => ["bun", "add", "--dev", "--exact", ...pkgs],
-    runCheckCi: "bunx biome ci --reporter=github .",
-    setupSteps: [
-      "      - uses: oven-sh/setup-bun@v2",
-      "      - run: bun install --frozen-lockfile",
-    ],
-  },
-  npm: {
-    lockfile: "package-lock.json",
-    install: (pkgs) => ["npm", "install", "--save-dev", "--save-exact", ...pkgs],
-    runCheckCi: "npx biome ci --reporter=github .",
-    setupSteps: [
-      "      - uses: actions/setup-node@v4",
-      "        with:",
-      "          node-version: 20",
-      "          cache: npm",
-      "      - run: npm ci",
-    ],
-  },
-  pnpm: {
-    lockfile: "pnpm-lock.yaml",
-    install: (pkgs) => ["pnpm", "add", "--save-dev", "--save-exact", ...pkgs],
-    runCheckCi: "pnpm exec biome ci --reporter=github .",
-    setupSteps: [
-      "      - uses: pnpm/action-setup@v4",
-      "      - uses: actions/setup-node@v4",
-      "        with:",
-      "          node-version: 20",
-      "          cache: pnpm",
-      "      - run: pnpm install --frozen-lockfile",
-    ],
-  },
-  yarn: {
-    lockfile: "yarn.lock",
-    install: (pkgs) => ["yarn", "add", "--dev", "--exact", ...pkgs],
-    runCheckCi: "yarn biome ci --reporter=github .",
-    setupSteps: [
-      "      - uses: actions/setup-node@v4",
-      "        with:",
-      "          node-version: 20",
-      "          cache: yarn",
-      "      - run: yarn install --frozen-lockfile",
-    ],
-  },
-};
+const RUNNER = runnerCommand();
 
 const BIOME_SUBCOMMANDS = {
   check: (paths) => ["check", ...paths],
@@ -70,18 +29,7 @@ const BIOME_SUBCOMMANDS = {
   ci: (paths) => ["ci", "--reporter=github", ...paths],
 };
 
-// Checked in order; the first match wins. Only "next" has its own Biome
-// lint domain — the others are still React under the hood, so they map to
-// the "base" preset, but we name what we found instead of guessing silently.
-const FRAMEWORK_DETECTORS = [
-  { label: "Next.js", preset: "next", deps: ["next"] },
-  { label: "TanStack Start", preset: "base", deps: ["@tanstack/react-start", "@tanstack/start"] },
-  { label: "React Router (framework mode)", preset: "base", deps: ["@react-router/dev"] },
-  { label: "Remix", preset: "base", deps: ["@remix-run/react", "@remix-run/node"] },
-  { label: "React", preset: "base", deps: ["react"] },
-];
-
-const HELP = `Usage: bunx ${KIT_NAME} <command> [options]
+const HELP = `Usage: ${RUNNER} ${KIT_NAME} <command> [options]
 
 Commands:
   init [options]   Set up Biome, scripts, hooks, and CI in the current project
@@ -116,13 +64,14 @@ auto-selected — pass --preset strict explicitly when you want it.
 
 check / check:fix / ci run the Biome binary already installed in this
 project's node_modules — you never need to call biome yourself. The
-package manager (bun, npm, pnpm, or yarn) used by \`init\` is detected
-from the "packageManager" field in package.json or from whichever
-lockfile is present. Bun is used as the fallback when neither is found.
-
-After \`init\` the command is installed in your project, so these run the
-local copy: \`bunx lintlane check\`, \`bunx lintlane check:fix\`,
-\`bunx lintlane ci\`, \`bunx lintlane commit\`, \`bunx lintlane ui\`.
+package manager (npm, pnpm, yarn, or bun) used by \`init\` is detected from
+the "packageManager" field in package.json, then from whichever lockfile is
+present, then from the tool you launched lintlane with (npx, pnpm dlx, yarn
+dlx, bunx). npm is used when none of those apply.
+
+After \`init\` the \`lintlane\` command is installed in your project, for
+example: \`npx lintlane check\`, \`pnpm exec lintlane check\`,
+\`yarn lintlane check\`, \`bunx lintlane check\`.
 `;
 
 function fail(message) {
@@ -138,32 +87,9 @@ function warn(message) {
   console.log(`! ${message}`);
 }
 
-function detectPackageManager(cwd, pkg) {
-  const declared = pkg.packageManager?.split("@")[0];
-  if (declared && declared in PACKAGE_MANAGERS) return declared;
-  for (const [name, pm] of Object.entries(PACKAGE_MANAGERS)) {
-    if (existsSync(join(cwd, pm.lockfile))) return name;
-  }
-  return "bun";
-}
-
-function detectPreset(pkg) {
-  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-  for (const detector of FRAMEWORK_DETECTORS) {
-    if (detector.deps.some((dep) => dep in deps)) {
-      return { preset: detector.preset, label: detector.label };
-    }
-  }
-  return { preset: "base", label: null };
-}
-
-function binPath(cwd, name) {
-  return join(cwd, "node_modules", ".bin", name);
-}
-
 // Everything after a bare "--" belongs to the subcommand (e.g. `commit -- -a -S`
 // hands "-a -S" to git commit), so it never reaches our own option parsing.
-const rawArgs = Bun.argv.slice(2);
+const rawArgs = process.argv.slice(2);
 const doubleDash = rawArgs.indexOf("--");
 const ownArgs = doubleDash < 0 ? rawArgs : rawArgs.slice(0, doubleDash);
 const passthroughArgs = doubleDash < 0 ? [] : rawArgs.slice(doubleDash + 1);
@@ -195,18 +121,13 @@ if (values.help && !["commit", "c", "check-commit"].includes(command)) {
 }
 
 if (command in BIOME_SUBCOMMANDS) {
-  const biome = binPath(cwd, "biome");
-  if (!existsSync(biome)) {
-    fail(`Biome isn't installed in this project. Run: bunx ${KIT_NAME} init`);
+  const biome = resolveBiome(cwd);
+  if (!biome) {
+    fail(`Biome isn't installed in this project. Run: ${RUNNER} ${KIT_NAME} init`);
   }
   const extraPaths = positionals.slice(1);
   const biomeArgs = BIOME_SUBCOMMANDS[command](extraPaths.length ? extraPaths : ["."]);
-  try {
-    await $`${biome} ${biomeArgs}`.cwd(cwd);
-  } catch (error) {
-    process.exit(error.exitCode ?? 1);
-  }
-  process.exit(0);
+  process.exit(await runInherit(biome[0], [...biome.slice(1), ...biomeArgs], { cwd }));
 }
 
 if (command === "commit" || command === "c") {
@@ -220,28 +141,32 @@ if (command === "check-commit") {
 }
 
 if (command === "ui") {
-  const biome = binPath(cwd, "biome");
-  if (!existsSync(biome)) {
-    fail(`Biome isn't installed in this project. Run: bunx ${KIT_NAME} init`);
+  const biome = resolveBiome(cwd);
+  if (!biome) {
+    fail(`Biome isn't installed in this project. Run: ${RUNNER} ${KIT_NAME} init`);
   }
   const { startUi } = await import("./ui-server.mjs");
   const uiPkgPath = join(cwd, "package.json");
-  const uiPkg = existsSync(uiPkgPath) ? await Bun.file(uiPkgPath).json() : {};
-  await startUi({
-    cwd,
-    biome,
-    pkg: uiPkg,
-    pmName: detectPackageManager(cwd, uiPkg),
-    kitDir: KIT_DIR,
-    port: values.port === undefined ? 4321 : Number(values.port),
-    open: !values["no-open"],
-  });
+  const uiPkg = existsSync(uiPkgPath) ? await readJson(uiPkgPath) : {};
+  try {
+    await startUi({
+      cwd,
+      biome,
+      pkg: uiPkg,
+      pmName: detectPackageManager(cwd, uiPkg).name,
+      kitDir: KIT_DIR,
+      port: values.port === undefined ? 4321 : Number(values.port),
+      open: !values["no-open"],
+    });
+  } catch (error) {
+    fail(error.message);
+  }
   await new Promise(() => {});
 }
 
 if (command !== "init") {
   fail(
-    `Unknown command "${command}". Usage: bunx ${KIT_NAME} <init|check|check:fix|ci|commit|check-commit|ui> [options]`,
+    `Unknown command "${command}". Usage: ${RUNNER} ${KIT_NAME} <init|check|check:fix|ci|commit|check-commit|ui> [options]`,
   );
 }
 
@@ -256,10 +181,9 @@ if (!existsSync(pkgPath)) {
   fail("No package.json found in the current directory.");
 }
 
-const pkg = await Bun.file(pkgPath).json();
-const pmName = detectPackageManager(cwd, pkg);
-const pm = PACKAGE_MANAGERS[pmName];
-ok(`Detected package manager: ${pmName}`);
+let pkg = await readJson(pkgPath);
+const { name: pmName, source: pmSource } = detectPackageManager(cwd, pkg);
+ok(`Detected package manager: ${pmName} (${pmSource})`);
 
 let preset = values.preset;
 if (preset === undefined) {
@@ -272,20 +196,31 @@ if (preset === undefined) {
   }
 }
 
-const devPackages = ["@biomejs/biome", `${KIT_NAME}@${KIT_VERSION}`];
+// LINTLANE_INSTALL_SPEC lets you install lintlane from somewhere other than the
+// registry (a tarball from `npm pack`, a local folder) when testing a build.
+const kitSpec = process.env.LINTLANE_INSTALL_SPEC || `${KIT_NAME}@${KIT_VERSION}`;
+const devPackages = ["@biomejs/biome", kitSpec];
 if (!values["no-hooks"]) devPackages.push("husky");
-const installArgv = pm.install(devPackages);
-const installCmd = installArgv.join(" ");
+const installArgv = installCommand(pmName, devPackages);
 
 if (values["skip-install"]) {
-  warn(`Skipped install. Run: ${installCmd}`);
+  warn(`Skipped install. Run: ${installArgv.join(" ")}`);
 } else {
-  try {
-    await $`${installArgv}`.cwd(cwd).quiet();
-    ok(`Installed ${devPackages.join(", ")}`);
-  } catch (error) {
-    fail(`Install failed: ${error.message}`);
+  const install = await runProcess(installArgv[0], installArgv.slice(1), { cwd });
+  if (install.code !== 0) {
+    const reason =
+      install.error?.code === "ENOENT"
+        ? `"${installArgv[0]}" was not found. Install it, or run again with --skip-install and install the packages yourself:\n  ${installArgv.join(" ")}`
+        : (install.stderr.toString().trim() || install.stdout.toString().trim())
+            .split("\n")
+            .slice(-8)
+            .join("\n");
+    fail(`Install failed (${installArgv.join(" ")}):\n${reason}`);
   }
+  ok(`Installed ${devPackages.join(", ")}`);
+  // The install just rewrote package.json (devDependencies). Re-read it, or the
+  // scripts we add below would be written over a stale copy and erase those entries.
+  pkg = await readJson(pkgPath);
 }
 
 const biomeJsonPath = join(cwd, "biome.json");
@@ -302,7 +237,7 @@ if (existsSync(biomeJsonPath) || existsSync(biomeJsoncPath)) {
   if (preset === "next") {
     config.files = { includes: ["**", "!**/.next", "!**/out", "!**/next-env.d.ts"] };
   }
-  await Bun.write(biomeJsonPath, `${JSON.stringify(config, null, 2)}\n`);
+  await writeFile(biomeJsonPath, `${JSON.stringify(config, null, 2)}\n`);
   ok(`Wrote biome.json (extends ${extendsSpecifier})`);
 }
 
@@ -340,7 +275,7 @@ if (!values["no-hooks"]) {
 }
 
 if (pkgChanged) {
-  await Bun.write(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
 }
 
 if (!values["no-hooks"]) {
@@ -355,13 +290,29 @@ if (!values["no-hooks"]) {
 
     for (const hook of hooks) {
       const hookPath = join(huskyDir, hook);
+      const template = await readFile(join(KIT_DIR, "templates", hook), "utf8");
       if (existsSync(hookPath)) {
-        warn(`.husky/${hook} already exists — left untouched`);
+        const existing = await readFile(hookPath, "utf8");
+        if (hook === "pre-commit" && isLegacyPreCommit(existing)) {
+          // The pre-2.6 hook re-staged files with `git update-index --again`, which also
+          // stages unstaged hunks of partially staged files. It's ours and untouched, so replace it.
+          await writeFile(hookPath, template);
+          await chmod(hookPath, 0o755);
+          ok("Replaced .husky/pre-commit (the old one could stage changes you hadn't staged)");
+          wroteHook = true;
+        } else if (hook === "pre-commit" && hasUnsafeRestaging(existing)) {
+          warn(
+            ".husky/pre-commit runs `git update-index --again`, which can stage changes you didn't stage. " +
+              "Replace its contents with node_modules/lintlane/templates/pre-commit (or delete it and re-run init).",
+          );
+        } else {
+          warn(`.husky/${hook} already exists — left untouched`);
+        }
         continue;
       }
-      await $`mkdir -p ${huskyDir}`.quiet();
-      await Bun.write(hookPath, await Bun.file(join(KIT_DIR, "templates", hook)).text());
-      await $`chmod 755 ${hookPath}`.quiet();
+      await mkdir(huskyDir, { recursive: true });
+      await writeFile(hookPath, template);
+      await chmod(hookPath, 0o755);
       ok(`Wrote .husky/${hook}`);
       wroteHook = true;
     }
@@ -372,12 +323,9 @@ if (!values["no-hooks"]) {
       } else {
         const husky = binPath(cwd, "husky");
         if (existsSync(husky)) {
-          try {
-            await $`${husky}`.cwd(cwd).quiet();
-            ok("Ran husky");
-          } catch (error) {
-            warn(`husky failed: ${error.message}`);
-          }
+          const ran = await runProcess(husky, [], { cwd });
+          if (ran.code === 0) ok("Ran husky");
+          else warn(`husky failed: ${(ran.stderr.toString() || ran.error?.message || "").trim()}`);
         } else {
           warn(`husky binary not found at ${husky} — run it manually once installed`);
         }
@@ -392,35 +340,9 @@ if (!values["no-ci"]) {
   if (existsSync(ciPath)) {
     warn(".github/workflows/biome.yml already exists — left untouched");
   } else {
-    // Catches commits that skipped the local hooks (--no-verify, GUI clients, fresh clones).
     const withCommitCheck = !values["no-commit-lint"] && !values["no-hooks"];
-    const commitCheckCheckout = withCommitCheck ? "\n        with:\n          fetch-depth: 0" : "";
-    const commitCheckStep = withCommitCheck
-      ? [
-          "",
-          "      - name: Check commit messages",
-          "        if: github.event_name == 'pull_request'",
-          "        run: node node_modules/lintlane/bin/check-commit.mjs --rev-range origin/${{ github.base_ref }}..HEAD",
-        ].join("\n")
-      : "";
-    const workflow = `name: Biome
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-
-jobs:
-  biome:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4${commitCheckCheckout}
-${pm.setupSteps.join("\n")}${commitCheckStep}
-      - run: ${pm.runCheckCi}
-`;
-    await $`mkdir -p ${workflowsDir}`.quiet();
-    await Bun.write(ciPath, workflow);
+    await mkdir(workflowsDir, { recursive: true });
+    await writeFile(ciPath, renderWorkflow({ pmName, kitName: KIT_NAME, withCommitCheck }));
     ok("Wrote .github/workflows/biome.yml");
   }
 }

package/bin/pre-commit.mjs

@@ -0,0 +1,55 @@
+#!/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);
+}