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

## Summary

Adds pre-flight git safety checks to `sentry init` so users are warned
before the wizard modifies their files. Checks that they're inside a git
repo with a clean working tree, and prompts to confirm if there are
concerns. With `--yes`, it warns and continues automatically.

## Changes

Adds a `checkGitStatus()` function in `src/lib/init/git.ts` that
verifies git repo status and working tree cleanliness. This gets called
in the `preamble()` phase of `runWizard` — after the experimental
warning, before any setup logic runs.

The approach follows sentry-wizard's pattern: warn users about
uncommitted changes so they can `git stash` or commit first, making it
easy to revert if something goes wrong.

12 unit tests cover the git module (repo detection, porcelain parsing,
interactive/non-interactive confirm paths). 3 integration tests in
wizard-runner verify the check is wired up correctly.

## Test Plan

- `bun test test/lib/init/git.test.ts` — 12 tests pass
- `bun test test/lib/init/wizard-runner.test.ts` — 25 tests pass
- `bun run lint` — clean

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: betegon

src/lib/init/git.ts

@@ -0,0 +1,85 @@
+/**
+ * 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 { confirm, isCancel, log } from "@clack/prompts";
+
+export function isInsideGitWorkTree(opts: { cwd: string }): boolean {
+  const result = Bun.spawnSync(["git", "rev-parse", "--is-inside-work-tree"], {
+    stdout: "ignore",
+    stderr: "ignore",
+    cwd: opts.cwd,
+  });
+  return result.success;
+}
+
+export function getUncommittedOrUntrackedFiles(opts: {
+  cwd: string;
+}): string[] {
+  const result = Bun.spawnSync(["git", "status", "--porcelain=v1"], {
+    stdout: "pipe",
+    stderr: "ignore",
+    cwd: opts.cwd,
+  });
+  if (!(result.success && result.stdout)) {
+    return [];
+  }
+  return result.stdout
+    .toString()
+    .trimEnd()
+    .split("\n")
+    .filter((line) => line.length > 0)
+    .map((line) => `- ${line.trimEnd()}`);
+}
+
+/**
+ * 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?",
+    });
+    if (isCancel(proceed)) {
+      return false;
+    }
+    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?",
+    });
+    if (isCancel(proceed)) {
+      return false;
+    }
+    return !!proceed;
+  }
+
+  return true;
+}

src/lib/init/wizard-runner.ts

@@ -9,6 +9,7 @@
 import { randomBytes } from "node:crypto";
 import { cancel, confirm, intro, log, spinner } from "@clack/prompts";
 import { MastraClient } from "@mastra/client-js";
+import { captureException } from "@sentry/bun";
 import { formatBanner } from "../banner.js";
 import { CLI_VERSION } from "../constants.js";
 import { getAuthToken } from "../db/auth.js";
@@ -25,6 +26,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 +193,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"
@@ -203,7 +209,19 @@ async function preamble(yes: boolean, dryRun: boolean): Promise<boolean> {
   process.stderr.write(`\n${formatBanner()}\n\n`);
   intro("sentry init");
 
-  const confirmed = await confirmExperimental(yes);
+  let confirmed: boolean;
+  try {
+    confirmed = await confirmExperimental(yes);
+  } catch (err) {
+    if (err instanceof WizardCancelledError) {
+      // Intentionally captured: track why users bail before completing
+      // instrumentation so we can improve the onboarding flow.
+      captureException(err);
+      process.exitCode = 0;
+      return false;
+    }
+    throw err;
+  }
   if (!confirmed) {
     cancel("Setup cancelled.");
     process.exitCode = 0;
@@ -214,13 +232,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;
   }
 
@@ -323,7 +348,10 @@ export async function runWizard(options: WizardOptions): Promise<void> {
     }
   } catch (err) {
     if (err instanceof WizardCancelledError) {
-      process.exitCode = 1;
+      // Intentionally captured: track why users bail before completing
+      // instrumentation so we can improve the onboarding flow.
+      captureException(err);
+      process.exitCode = 0;
       return;
     }
     if (spinState.running) {

test/lib/init/git.test.ts

@@ -0,0 +1,223 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+// 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";
+
+const noop = () => {
+  /* suppress output */
+};
+
+let spawnSyncSpy: ReturnType<typeof spyOn>;
+let confirmSpy: ReturnType<typeof spyOn>;
+let isCancelSpy: ReturnType<typeof spyOn>;
+let logWarnSpy: ReturnType<typeof spyOn>;
+
+beforeEach(() => {
+  spawnSyncSpy = spyOn(Bun, "spawnSync");
+  confirmSpy = spyOn(clack, "confirm").mockResolvedValue(true);
+  isCancelSpy = spyOn(clack, "isCancel").mockImplementation(
+    (v: unknown) => v === Symbol.for("cancel")
+  );
+  logWarnSpy = spyOn(clack.log, "warn").mockImplementation(noop);
+});
+
+afterEach(() => {
+  spawnSyncSpy.mockRestore();
+  confirmSpy.mockRestore();
+  isCancelSpy.mockRestore();
+  logWarnSpy.mockRestore();
+});
+
+describe("isInsideGitWorkTree", () => {
+  test("returns true when git succeeds", () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 0, success: true });
+
+    expect(isInsideGitWorkTree({ cwd: "/tmp" })).toBe(true);
+    expect(spawnSyncSpy).toHaveBeenCalledWith(
+      ["git", "rev-parse", "--is-inside-work-tree"],
+      expect.objectContaining({ cwd: "/tmp" })
+    );
+  });
+
+  test("returns false when git fails", () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 128, success: false });
+
+    expect(isInsideGitWorkTree({ cwd: "/tmp" })).toBe(false);
+  });
+});
+
+describe("getUncommittedOrUntrackedFiles", () => {
+  test("parses porcelain output into file list", () => {
+    spawnSyncSpy.mockReturnValue({
+      stdout: Buffer.from(" M src/index.ts\n?? new-file.ts\n"),
+      exitCode: 0,
+      success: true,
+    });
+
+    const files = getUncommittedOrUntrackedFiles({ cwd: "/tmp" });
+
+    expect(files).toEqual(["-  M src/index.ts", "- ?? new-file.ts"]);
+  });
+
+  test("returns empty array for clean repo", () => {
+    spawnSyncSpy.mockReturnValue({
+      stdout: Buffer.from(""),
+      exitCode: 0,
+      success: true,
+    });
+
+    expect(getUncommittedOrUntrackedFiles({ cwd: "/tmp" })).toEqual([]);
+  });
+
+  test("returns empty array on error", () => {
+    spawnSyncSpy.mockReturnValue({
+      stdout: Buffer.from(""),
+      exitCode: 128,
+      success: false,
+    });
+
+    expect(getUncommittedOrUntrackedFiles({ cwd: "/tmp" })).toEqual([]);
+  });
+});
+
+describe("checkGitStatus", () => {
+  test("returns true silently for clean git repo", async () => {
+    spawnSyncSpy
+      // isInsideGitWorkTree -> true
+      .mockReturnValueOnce({ exitCode: 0, success: true })
+      // getUncommittedOrUntrackedFiles -> clean
+      .mockReturnValueOnce({
+        stdout: Buffer.from(""),
+        exitCode: 0,
+        success: true,
+      });
+
+    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 () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 128, success: false });
+    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 () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 128, success: false });
+    confirmSpy.mockResolvedValue(false);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(false);
+  });
+
+  test("returns false without throwing when user cancels not-in-git-repo prompt", async () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 128, success: false });
+    confirmSpy.mockResolvedValue(Symbol.for("cancel"));
+
+    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 () => {
+    spawnSyncSpy.mockReturnValue({ exitCode: 128, success: false });
+
+    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 () => {
+    spawnSyncSpy
+      // isInsideGitWorkTree -> true
+      .mockReturnValueOnce({ exitCode: 0, success: true })
+      // getUncommittedOrUntrackedFiles -> dirty
+      .mockReturnValueOnce({
+        stdout: Buffer.from(" M dirty.ts\n"),
+        exitCode: 0,
+        success: true,
+      });
+    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 () => {
+    spawnSyncSpy
+      .mockReturnValueOnce({ exitCode: 0, success: true })
+      .mockReturnValueOnce({
+        stdout: Buffer.from(" M dirty.ts\n"),
+        exitCode: 0,
+        success: true,
+      });
+    confirmSpy.mockResolvedValue(false);
+
+    const result = await checkGitStatus({ cwd: "/tmp", yes: false });
+
+    expect(result).toBe(false);
+  });
+
+  test("returns false without throwing when user cancels dirty-tree prompt", async () => {
+    spawnSyncSpy
+      .mockReturnValueOnce({ exitCode: 0, success: true })
+      .mockReturnValueOnce({
+        stdout: Buffer.from(" M dirty.ts\n"),
+        exitCode: 0,
+        success: true,
+      });
+    confirmSpy.mockResolvedValue(Symbol.for("cancel"));
+
+    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 () => {
+    spawnSyncSpy
+      .mockReturnValueOnce({ exitCode: 0, success: true })
+      .mockReturnValueOnce({
+        stdout: Buffer.from(" M dirty.ts\n?? new.ts\n"),
+        exitCode: 0,
+        success: true,
+      });
+
+    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();
+  });
+});