lintlane 3.0.1 → 4.0.0

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;
+  }
+}

package/bin/proc.mjs

@@ -4,7 +4,7 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 const isWindows = process.platform === "win32";
 
@@ -29,6 +29,25 @@ export function resolveBiome(cwd) {
   }
 }
 
+/**
+ * The argv that runs a binary shipped by one of lintlane's own dependencies
+ * (lint-staged, commitlint, commitizen). Resolved from lintlane's location, so it
+ * works with every package manager, including pnpm's strict node_modules layout.
+ * Returns null if the package isn't installed.
+ */
+export function resolveTool(pkgName, binName = pkgName) {
+  try {
+    const require = createRequire(import.meta.url);
+    const manifestPath = require.resolve(`${pkgName}/package.json`);
+    const manifest = require(manifestPath);
+    const rel = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[binName];
+    if (!rel) return null;
+    return [process.execPath, join(dirname(manifestPath), rel)];
+  } catch {
+    return null;
+  }
+}
+
 // Windows can't spawn .cmd shims (npm, pnpm, yarn, node_modules/.bin/*) without
 // a shell. git and node are real executables and are spawned directly.
 function prepare(command, args) {

package/bin/project.mjs

@@ -126,8 +126,21 @@ export function detectPreset(pkg) {
   return { preset: "base", label: null };
 }
 
-/** The GitHub Actions workflow `init` writes. */
-export function renderWorkflow({ pmName, kitName, withCommitCheck }) {
+const RUN_SCRIPT_PREFIX = { npm: "npm run", pnpm: "pnpm run", yarn: "yarn run", bun: "bun run" };
+
+/** The `run:` command a check has in the generated workflow, or null if it has none. */
+export function ciCommand(pmName, step) {
+  if (step.id === "biome") return PACKAGE_MANAGERS[pmName].runCheckCi;
+  if (step.ci && step.script) return `${RUN_SCRIPT_PREFIX[pmName]} ${step.script}`;
+  return null;
+}
+
+/**
+ * The GitHub Actions workflow `init` writes. `checks` is the resolved list from
+ * checks.mjs, so the workflow runs exactly what the CLI and dashboard run.
+ * Without it, only Biome.
+ */
+export function renderWorkflow({ pmName, kitName, withCommitCheck, checks }) {
   const pm = PACKAGE_MANAGERS[pmName];
   // Catches commits that skipped the local hooks (--no-verify, GUI clients, fresh clones).
   const checkout = withCommitCheck ? "\n        with:\n          fetch-depth: 0" : "";
@@ -136,9 +149,13 @@ export function renderWorkflow({ pmName, kitName, withCommitCheck }) {
         "",
         "      - name: Check commit messages",
         "        if: github.event_name == 'pull_request'",
-        `        run: node node_modules/${kitName}/bin/check-commit.mjs --rev-range origin/\${{ github.base_ref }}..HEAD`,
+        `        run: node node_modules/${kitName}/bin/cli.mjs check-commit --rev-range origin/\${{ github.base_ref }}..HEAD`,
       ].join("\n")
     : "";
+  const commands = (checks ?? [{ id: "biome", ci: true }])
+    .map((step) => ciCommand(pmName, step))
+    .filter(Boolean);
+  const runSteps = commands.map((command) => `      - run: ${command}`).join("\n");
   return `name: Biome
 
 on:
@@ -153,7 +170,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4${checkout}
 ${pm.setupSteps.join("\n")}${commitStep}
-      - run: ${pm.runCheckCi}
+${runSteps}
 `;
 }
 
@@ -178,3 +195,82 @@ export function isLegacyPreCommit(content) {
 export function hasUnsafeRestaging(content) {
   return /git\s+update-index\s+--again/.test(content);
 }
+
+// Hooks written by earlier versions of lintlane that did their own work in
+// bin/*.mjs files which no longer exist. An untouched copy is safe to replace.
+const LEGACY_HOOKS = {
+  "pre-commit": [
+    'if [ -f node_modules/lintlane/bin/pre-commit.mjs ]; then\n  node node_modules/lintlane/bin/pre-commit.mjs\nelse\n  echo "lintlane: node_modules/lintlane not found; skipping staged-file checks. Run your package manager\'s install." >&2\nfi',
+  ],
+  "commit-msg": [
+    '[ -f node_modules/lintlane/bin/commit-msg.mjs ] || exit 0\nnode node_modules/lintlane/bin/commit-msg.mjs "$1"',
+  ],
+  "prepare-commit-msg": [
+    '[ -f node_modules/lintlane/bin/prepare-commit-msg.mjs ] || exit 0\nnode node_modules/lintlane/bin/prepare-commit-msg.mjs "$1" "$2"',
+  ],
+  "pre-push": [
+    '[ -f node_modules/lintlane/bin/pre-push-check.mjs ] || exit 0\nnode node_modules/lintlane/bin/pre-push-check.mjs "$1" "$2"',
+  ],
+};
+
+const REMOVED_ENTRYPOINTS =
+  /bin\/(pre-commit|commit-msg|prepare-commit-msg|pre-push-check|staged|commit-lint)\.mjs/;
+
+/**
+ * What a hook file is, relative to this version of lintlane:
+ *   "current"  the shipped template
+ *   "legacy"   an untouched hook from an older lintlane (safe to replace)
+ *   "stale"    edited, but still calls files lintlane no longer ships (needs a human)
+ *   "unsafe"   edited, and re-stages with `git update-index --again`
+ *   "custom"   the project's own hook
+ */
+export function classifyHook(name, content, template) {
+  const normalized = content.trim();
+  if (normalized === template.trim()) return "current";
+  if (name === "pre-commit" && isLegacyPreCommit(content)) return "legacy";
+  if ((LEGACY_HOOKS[name] ?? []).some((legacy) => legacy === normalized)) return "legacy";
+  if (REMOVED_ENTRYPOINTS.test(content)) return "stale";
+  if (name === "pre-commit" && hasUnsafeRestaging(content)) return "unsafe";
+  return "custom";
+}
+
+/** Does the project already configure lint-staged? (package.json key or a config file) */
+export function hasLintStagedConfig(cwd, pkg) {
+  if (pkg?.["lint-staged"]) return true;
+  return [
+    ".lintstagedrc",
+    ".lintstagedrc.json",
+    ".lintstagedrc.yaml",
+    ".lintstagedrc.yml",
+    ".lintstagedrc.js",
+    ".lintstagedrc.cjs",
+    ".lintstagedrc.mjs",
+    "lint-staged.config.js",
+    "lint-staged.config.cjs",
+    "lint-staged.config.mjs",
+  ].some((file) => existsSync(join(cwd, file)));
+}
+
+/** Does the project already configure commitlint? */
+export function hasCommitlintConfig(cwd, pkg) {
+  if (pkg?.commitlint) return true;
+  return [
+    ".commitlintrc",
+    ".commitlintrc.json",
+    ".commitlintrc.yaml",
+    ".commitlintrc.yml",
+    ".commitlintrc.js",
+    ".commitlintrc.cjs",
+    ".commitlintrc.mjs",
+    ".commitlintrc.ts",
+    "commitlint.config.js",
+    "commitlint.config.cjs",
+    "commitlint.config.mjs",
+    "commitlint.config.ts",
+  ].some((file) => existsSync(join(cwd, file)));
+}
+
+export const LINT_STAGED_CONFIG = {
+  "*": "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true",
+};
+export const COMMITIZEN_PATH = "lintlane/presets/commitizen.cjs";