fix[PREPARE]: Conditionally install Git hooks

Author: parazeeknova

.github/copilot-instructions.md

@@ -1,6 +1,6 @@
 {
   "name": "lumen",
-  "version": "0.4.115",
+  "version": "0.4.116",
   "devDependencies": {
     "@biomejs/biome": "^2.4.8",
     "@changesets/cli": "^2.30.0",
@@ -15,6 +15,7 @@
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "babel-plugin-react-compiler": "^1.0.0",
+    "bun-types": "^1.3.11",
     "concurrently": "^9.2.1",
     "fake-indexeddb": "^6.2.5",
     "happy-dom": "^20.8.7",
@@ -37,7 +38,7 @@
     "changeset": "changeset",
     "changeset:version": "changeset version",
     "postinstall": "bun run db:gen",
-    "prepare": "lefthook install",
+    "prepare": "bun ./scripts/install/prepare.ts",
     "dev": "turbo run dev",
     "dev:web": "concurrently --names \"web,workers\" --prefix-colors \"blue,red\" \"cd apps/web && bun run dev\" \"cd apps/workers && bun run dev\"",
     "dev:linux": "concurrently --names \"native,workers\" --prefix-colors \"yellow,red\" \"cd apps/native && bun run dev:linux\" \"cd apps/workers && bun run dev\"",

bun.lock

@@ -0,0 +1,109 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import { detectGitState, installHooks, runPrepare } from "./prepare";
+
+describe("detectGitState", () => {
+  test("returns worktree when git rev-parse succeeds", () => {
+    expect(
+      detectGitState(() => ({
+        status: 0,
+      }))
+    ).toBe("worktree");
+  });
+
+  test("returns missing when git rev-parse fails", () => {
+    expect(
+      detectGitState(() => ({
+        status: 128,
+      }))
+    ).toBe("missing");
+  });
+
+  test("returns unavailable when git cannot be executed", () => {
+    expect(
+      detectGitState(() => ({
+        error: new Error("spawn git ENOENT"),
+        status: null,
+      }))
+    ).toBe("unavailable");
+  });
+});
+
+describe("installHooks", () => {
+  test("returns the lefthook exit code", () => {
+    expect(
+      installHooks((command, args, options) => {
+        expect(command).toBe("lefthook");
+        expect(args).toEqual(["install"]);
+        expect(options).toEqual({ stdio: "inherit" });
+
+        return {
+          status: 0,
+        };
+      })
+    ).toBe(0);
+  });
+
+  test("throws when lefthook cannot be executed", () => {
+    expect(() =>
+      installHooks(() => ({
+        error: new Error("spawn lefthook ENOENT"),
+        status: null,
+      }))
+    ).toThrow("spawn lefthook ENOENT");
+  });
+});
+
+describe("runPrepare", () => {
+  test("skips hook installation outside a git worktree", () => {
+    const log = mock(() => undefined);
+    const runInstallHooks = mock(() => 1);
+
+    expect(
+      runPrepare({
+        detectGitState: () => "missing",
+        installHooks: runInstallHooks,
+        log,
+      })
+    ).toBe(0);
+
+    expect(runInstallHooks).not.toHaveBeenCalled();
+    expect(log).toHaveBeenCalledWith(
+      "Skipping lefthook install: no git worktree detected."
+    );
+  });
+
+  test("skips hook installation when git is unavailable", () => {
+    const log = mock(() => undefined);
+    const runInstallHooks = mock(() => 1);
+
+    expect(
+      runPrepare({
+        detectGitState: () => "unavailable",
+        installHooks: runInstallHooks,
+        log,
+      })
+    ).toBe(0);
+
+    expect(runInstallHooks).not.toHaveBeenCalled();
+    expect(log).toHaveBeenCalledWith(
+      "Skipping lefthook install: git is unavailable in this environment."
+    );
+  });
+
+  test("installs hooks inside a git worktree", () => {
+    const log = mock(() => undefined);
+    const runInstallHooks = mock(() => 7);
+
+    expect(
+      runPrepare({
+        detectGitState: () => "worktree",
+        installHooks: runInstallHooks,
+        log,
+      })
+    ).toBe(7);
+
+    expect(runInstallHooks).toHaveBeenCalledTimes(1);
+    expect(log).not.toHaveBeenCalled();
+  });
+});

package.json

@@ -0,0 +1,85 @@
+import { spawnSync } from "node:child_process";
+
+type GitState = "missing" | "unavailable" | "worktree";
+
+interface CommandOptions {
+  stdio: "ignore" | "inherit";
+}
+
+interface CommandResult {
+  error?: Error;
+  status: number | null;
+}
+
+type CommandRunner = (
+  command: string,
+  args: string[],
+  options: CommandOptions
+) => CommandResult;
+
+interface PrepareDependencies {
+  detectGitState: () => GitState;
+  installHooks: () => number;
+  log: (message: string) => void;
+}
+
+export const spawnCommand: CommandRunner = (command, args, options) => {
+  const result = spawnSync(command, args, options);
+
+  return {
+    error: result.error,
+    status: result.status,
+  };
+};
+
+export function detectGitState(
+  commandRunner: CommandRunner = spawnCommand
+): GitState {
+  const result = commandRunner("git", ["rev-parse", "--is-inside-work-tree"], {
+    stdio: "ignore",
+  });
+
+  if (result.error) {
+    return "unavailable";
+  }
+
+  return result.status === 0 ? "worktree" : "missing";
+}
+
+export function installHooks(
+  commandRunner: CommandRunner = spawnCommand
+): number {
+  const result = commandRunner("lefthook", ["install"], {
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result.status ?? 1;
+}
+
+export function runPrepare({
+  detectGitState: getGitState = detectGitState,
+  installHooks: runInstallHooks = installHooks,
+  log = console.log,
+}: Partial<PrepareDependencies> = {}): number {
+  const gitState = getGitState();
+
+  if (gitState === "missing") {
+    log("Skipping lefthook install: no git worktree detected.");
+    return 0;
+  }
+
+  if (gitState === "unavailable") {
+    log("Skipping lefthook install: git is unavailable in this environment.");
+    return 0;
+  }
+
+  return runInstallHooks();
+}
+
+if (import.meta.main) {
+  process.exit(runPrepare());
+}

scripts/install/prepare.test.ts

@@ -3,7 +3,7 @@
     "target": "ES2021",
     "module": "preserve",
     "moduleResolution": "bundler",
-    "types": ["bun"],
+    "types": ["node", "bun-types"],
     "strict": true,
     "noEmit": true,
     "skipLibCheck": true,