feat(init): add git safety checks before wizard modifies files

betegon · claude · betegon · commit ce44816d86e8 · 2026-03-10T12:57:02.000+01:00
Checks that the user is inside a git repo with a clean working tree
before the init wizard starts. Prompts to confirm if concerns are found,
or warns and continues when --yes is passed.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/lib/init/git.ts b/src/lib/init/git.ts
@@ -0,0 +1,86 @@
+/**
+ * Git Safety Checks
+ *
+ * Pre-flight checks to verify the user is in a git repo with a clean
+ * working tree before the init wizard starts modifying files.
+ */
+
+import { execFileSync } from "node:child_process";
+import { confirm, log } from "@clack/prompts";
+import { abortIfCancelled } from "./clack-utils.js";
+
+export function isInsideGitWorkTree(opts: { cwd: string }): boolean {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      stdio: "ignore",
+      cwd: opts.cwd,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getUncommittedOrUntrackedFiles(opts: {
+  cwd: string;
+}): string[] {
+  try {
+    const output = execFileSync("git", ["status", "--porcelain=v1"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      cwd: opts.cwd,
+    });
+    return output
+      .toString()
+      .trim()
+      .split("\n")
+      .filter((line) => line.length > 0)
+      .map((line) => `- ${line.trim()}`);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Checks git status and prompts the user if there are concerns.
+ * Returns `true` to continue, `false` to abort.
+ */
+export async function checkGitStatus(opts: {
+  cwd: string;
+  yes: boolean;
+}): Promise<boolean> {
+  const { cwd, yes } = opts;
+
+  if (!isInsideGitWorkTree({ cwd })) {
+    if (yes) {
+      log.warn(
+        "You are not inside a git repository. Unable to revert changes if something goes wrong."
+      );
+      return true;
+    }
+    const proceed = await confirm({
+      message:
+        "You are not inside a git repository. Unable to revert changes if something goes wrong. Continue?",
+    });
+    abortIfCancelled(proceed);
+    return !!proceed;
+  }
+
+  const uncommitted = getUncommittedOrUntrackedFiles({ cwd });
+  if (uncommitted.length > 0) {
+    const fileList = uncommitted.join("\n");
+    if (yes) {
+      log.warn(
+        `You have uncommitted or untracked files:\n${fileList}\nProceeding anyway (--yes).`
+      );
+      return true;
+    }
+    log.warn(`You have uncommitted or untracked files:\n${fileList}`);
+    const proceed = await confirm({
+      message: "Continue with uncommitted changes?",
+    });
+    abortIfCancelled(proceed);
+    return !!proceed;
+  }
+
+  return true;
+}
diff --git a/src/lib/init/wizard-runner.ts b/src/lib/init/wizard-runner.ts
@@ -25,6 +25,7 @@ import {
   WORKFLOW_ID,
 } from "./constants.js";
 import { formatError, formatResult } from "./formatters.js";
+import { checkGitStatus } from "./git.js";
 import { handleInteractive } from "./interactive.js";
 import { handleLocalOp, precomputeDirListing } from "./local-ops.js";
 import type {
@@ -191,7 +192,11 @@ async function confirmExperimental(yes: boolean): Promise<boolean> {
  * Pre-flight checks: TTY guard, banner, intro, and experimental warning.
  * Returns `true` when the wizard should continue, `false` to abort.
  */
-async function preamble(yes: boolean, dryRun: boolean): Promise<boolean> {
+async function preamble(
+  directory: string,
+  yes: boolean,
+  dryRun: boolean
+): Promise<boolean> {
   if (!(yes || process.stdin.isTTY)) {
     process.stderr.write(
       "Error: Interactive mode requires a terminal. Use --yes for non-interactive mode.\n"
@@ -214,13 +219,20 @@ async function preamble(yes: boolean, dryRun: boolean): Promise<boolean> {
     log.warn("Dry-run mode: no files will be modified.");
   }
 
+  const gitOk = await checkGitStatus({ cwd: directory, yes });
+  if (!gitOk) {
+    cancel("Setup cancelled.");
+    process.exitCode = 0;
+    return false;
+  }
+
   return true;
 }
 
 export async function runWizard(options: WizardOptions): Promise<void> {
   const { directory, yes, dryRun, features } = options;
 
-  if (!(await preamble(yes, dryRun))) {
+  if (!(await preamble(directory, yes, dryRun))) {
     return;
   }
 
diff --git a/test/lib/init/git.test.ts b/test/lib/init/git.test.ts
@@ -0,0 +1,196 @@
+/**
+ * Git Safety Checks Unit Tests
+ *
+ * Tests for isInsideGitWorkTree, getUncommittedOrUntrackedFiles,
+ * and checkGitStatus using spyOn on namespace imports.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+// biome-ignore lint/performance/noNamespaceImport: spyOn requires object reference
+import * as cp from "node:child_process";
+// biome-ignore lint/performance/noNamespaceImport: spyOn requires object reference
+import * as clack from "@clack/prompts";
+import {
+  checkGitStatus,
+  getUncommittedOrUntrackedFiles,
+  isInsideGitWorkTree,
+} from "../../../src/lib/init/git.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+const noop = () => {
+  /* suppress output */
+};
+
+// ── Spy declarations ────────────────────────────────────────────────────────
+
+let execFileSyncSpy: ReturnType<typeof spyOn>;
+let confirmSpy: ReturnType<typeof spyOn>;
+let logWarnSpy: ReturnType<typeof spyOn>;
+
+// ── Setup / Teardown ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+  execFileSyncSpy = spyOn(cp, "execFileSync");
+  confirmSpy = spyOn(clack, "confirm").mockResolvedValue(true);
+  logWarnSpy = spyOn(clack.log, "warn").mockImplementation(noop);
+});
+
+afterEach(() => {
+  execFileSyncSpy.mockRestore();
+  confirmSpy.mockRestore();
+  logWarnSpy.mockRestore();
+});
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+
+describe("isInsideGitWorkTree", () => {
+  test("returns true when git succeeds", () => {
+    execFileSyncSpy.mockReturnValue(Buffer.from("true\n"));
+
+    expect(isInsideGitWorkTree({ cwd: "/tmp" })).toBe(true);
+    expect(execFileSyncSpy).toHaveBeenCalledWith(
+      "git",
+      ["rev-parse", "--is-inside-work-tree"],
+      expect.objectContaining({ cwd: "/tmp" })
+    );
+  });
+
+  test("returns false when git fails", () => {
+    execFileSyncSpy.mockImplementation(() => {
+      throw new Error("not a git repository");
+    });
+
+    expect(isInsideGitWorkTree({ cwd: "/tmp" })).toBe(false);
+  });
+});
+
+describe("getUncommittedOrUntrackedFiles", () => {
+  test("parses porcelain output into file list", () => {
+    execFileSyncSpy.mockReturnValue(
+      Buffer.from(" M src/index.ts\n?? new-file.ts\n")
+    );
+
+    const files = getUncommittedOrUntrackedFiles({ cwd: "/tmp" });
+
+    expect(files).toEqual(["- M src/index.ts", "- ?? new-file.ts"]);
+  });
+
+  test("returns empty array for clean repo", () => {
+    execFileSyncSpy.mockReturnValue(Buffer.from(""));
+
+    expect(getUncommittedOrUntrackedFiles({ cwd: "/tmp" })).toEqual([]);
+  });
+
+  test("returns empty array on error", () => {
+    execFileSyncSpy.mockImplementation(() => {
+      throw new Error("git failed");
+    });
+
+    expect(getUncommittedOrUntrackedFiles({ cwd: "/tmp" })).toEqual([]);
+  });
+});
+
+describe("checkGitStatus", () => {
+  test("returns true silently for clean git repo", async () => {
+    // isInsideGitWorkTree -> true
+    execFileSyncSpy
+      .mockReturnValueOnce(Buffer.from("true\n"))
+      // getUncommittedOrUntrackedFiles -> clean
+      .mockReturnValueOnce(Buffer.from(""));
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(true);
+    expect(confirmSpy).not.toHaveBeenCalled();
+    expect(logWarnSpy).not.toHaveBeenCalled();
+  });
+
+  test("prompts when not in git repo (interactive) and returns true on confirm", async () => {
+    execFileSyncSpy.mockImplementation(() => {
+      throw new Error("not a git repo");
+    });
+    confirmSpy.mockResolvedValue(true);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(true);
+    expect(confirmSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("not inside a git repository"),
+      })
+    );
+  });
+
+  test("prompts when not in git repo (interactive) and returns false on decline", async () => {
+    execFileSyncSpy.mockImplementation(() => {
+      throw new Error("not a git repo");
+    });
+    confirmSpy.mockResolvedValue(false);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(false);
+  });
+
+  test("warns and auto-continues when not in git repo with --yes", async () => {
+    execFileSyncSpy.mockImplementation(() => {
+      throw new Error("not a git repo");
+    });
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: true });
+
+    expect(result).toBe(true);
+    expect(logWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("not inside a git repository")
+    );
+    expect(confirmSpy).not.toHaveBeenCalled();
+  });
+
+  test("shows files and prompts for dirty tree (interactive), returns true on confirm", async () => {
+    // isInsideGitWorkTree -> true
+    execFileSyncSpy
+      .mockReturnValueOnce(Buffer.from("true\n"))
+      // getUncommittedOrUntrackedFiles -> dirty
+      .mockReturnValueOnce(Buffer.from(" M dirty.ts\n"));
+    confirmSpy.mockResolvedValue(true);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(true);
+    expect(logWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("uncommitted")
+    );
+    expect(confirmSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("uncommitted changes"),
+      })
+    );
+  });
+
+  test("shows files and prompts for dirty tree (interactive), returns false on decline", async () => {
+    execFileSyncSpy
+      .mockReturnValueOnce(Buffer.from("true\n"))
+      .mockReturnValueOnce(Buffer.from(" M dirty.ts\n"));
+    confirmSpy.mockResolvedValue(false);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(false);
+  });
+
+  test("warns with file list and auto-continues for dirty tree with --yes", async () => {
+    execFileSyncSpy
+      .mockReturnValueOnce(Buffer.from("true\n"))
+      .mockReturnValueOnce(Buffer.from(" M dirty.ts\n?? new.ts\n"));
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: true });
+
+    expect(result).toBe(true);
+    expect(logWarnSpy).toHaveBeenCalled();
+    const warnMsg: string = logWarnSpy.mock.calls[0][0];
+    expect(warnMsg).toContain("uncommitted");
+    expect(warnMsg).toContain("M dirty.ts");
+    expect(confirmSpy).not.toHaveBeenCalled();
+  });
+});
diff --git a/test/lib/init/wizard-runner.test.ts b/test/lib/init/wizard-runner.test.ts
