tdd-enforcer 0.2.2 → 0.2.5

package/engine/git.test.ts

@@ -1,271 +1,530 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { initGit, snapshot, changesSinceSnapshot, modifiedFiles, untrackedFiles, restoreFilesTo, headHash, headMessage, hasParent, resetHard, undoLastCommit } from "./git.js";
-
-let testDir: string;
-
-beforeAll(() => {
-  testDir = join(tmpdir(), `tdd-git-test-${Date.now()}`);
-  mkdirSync(join(testDir, ".pi", "tdd"), { recursive: true });
-  mkdirSync(join(testDir, "src"), { recursive: true });
-  writeFileSync(join(testDir, "src", "main.ts"), "// initial", "utf-8");
-});
-
-afterAll(() => {
-  rmSync(testDir, { recursive: true, force: true });
-});
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import {
+  initGit,
+  snapshot,
+  modifiedFiles,
+  untrackedFiles,
+  changesSinceSnapshot,
+  restoreFilesTo,
+  headHash,
+  headMessage,
+  hasParent,
+  resetHard,
+  undoLastCommit,
+  gitStashCreate,
+  stageFiles,
+} from "./git.js";
+import type { GitDeps } from "./git.js";
 
 describe("git operations", () => {
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
+    });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
   it("initGit creates private git repo", () => {
-    initGit(testDir);
-    expect(existsSync(join(testDir, ".pi", "tdd", ".git"))).toBe(true);
-    expect(existsSync(join(testDir, ".pi", "tdd", ".gitignore"))).toBe(true);
+    initGit("/test", deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git init"),
+      expect.any(Object),
+    );
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git config core.worktree"),
+      expect.any(Object),
+    );
+    expect(deps.mkdirSync).toHaveBeenCalled();
+    expect(deps.writeFileSync).toHaveBeenCalled();
+    // Every git command targets the private repo, not the main project .git
+    for (const call of (deps.execSync as any).mock.calls) {
+      expect(call[1].env.GIT_DIR).toBe("/test/.pi/tdd/.git");
+      expect(call[1].env.GIT_WORK_TREE).toBe("/test");
+    }
   });
 
   it("has initial commit after init", () => {
-    const hash = headHash(testDir);
-    expect(hash).toBeTruthy();
-    expect(hash.length).toBeGreaterThan(10);
+    outputs["rev-parse HEAD"] = "abc123def456\n";
+    const hash = headHash("/test", deps);
+    expect(hash).toBe("abc123def456");
   });
 
   it("snapshot captures changes", () => {
-    writeFileSync(join(testDir, "src", "main.ts"), "// modified", "utf-8");
-    const hash = snapshot(testDir, "green");
-    expect(hash).toBeTruthy();
+    outputs["rev-parse HEAD"] = "hash123\n";
+    const hash = snapshot("/test", "green", deps);
+    expect(hash).toBe("hash123");
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining('commit --allow-empty -m "tdd: green"'),
+      expect.any(Object),
+    );
   });
 
   it("modifiedFiles returns changed files", () => {
-    writeFileSync(join(testDir, "src", "main.ts"), "// changed again", "utf-8");
-    const modified = modifiedFiles(testDir);
+    outputs["diff --name-only HEAD"] = "src/main.ts\n";
+    const modified = modifiedFiles("/test", deps);
     expect(modified).toContain("src/main.ts");
   });
 
   it("untrackedFiles returns new files", () => {
-    writeFileSync(join(testDir, "newfile.ts"), "// new", "utf-8");
-    const untracked = untrackedFiles(testDir);
+    outputs["ls-files --others --exclude-standard"] = "newfile.ts\n";
+    const untracked = untrackedFiles("/test", deps);
     expect(untracked).toContain("newfile.ts");
   });
 
   it("changesSinceSnapshot combines modified + untracked", () => {
-    writeFileSync(join(testDir, "src", "main.ts"), "// yet another change", "utf-8");
-    writeFileSync(join(testDir, "another.ts"), "// also new", "utf-8");
-    const changes = changesSinceSnapshot(testDir);
+    outputs["diff --name-only HEAD"] = "src/main.ts\n";
+    outputs["ls-files --others --exclude-standard"] = "newfile.ts\n";
+    const changes = changesSinceSnapshot("/test", deps);
     expect(changes).toContain("src/main.ts");
-    expect(changes).toContain("another.ts");
+    expect(changes).toContain("newfile.ts");
   });
 
   it("restoreFilesTo reverts specific files", () => {
-    writeFileSync(join(testDir, "src", "main.ts"), "// to be reverted", "utf-8");
-    expect(modifiedFiles(testDir)).toContain("src/main.ts");
-
-    restoreFilesTo(testDir, ["src/main.ts"]);
-    expect(modifiedFiles(testDir)).not.toContain("src/main.ts");
+    outputs["ls-files"] = "src/main.ts\n";
+    restoreFilesTo("/test", ["src/main.ts"], undefined, deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git restore"),
+      expect.any(Object),
+    );
   });
 
   it("modifiedFiles returns empty when HEAD matches working tree", () => {
-    expect(modifiedFiles(testDir)).not.toContain("src/main.ts");
+    outputs["diff --name-only HEAD"] = "";
+    const modified = modifiedFiles("/test", deps);
+    expect(modified).not.toContain("src/main.ts");
   });
 
   it("untrackedFiles returns empty when no new files", () => {
-    const untracked = untrackedFiles(testDir);
+    outputs["ls-files --others --exclude-standard"] = "";
+    const untracked = untrackedFiles("/test", deps);
     expect(untracked).not.toContain("src/main.ts");
   });
 
   it("changesSinceSnapshot deduplicates when file is both modified and untracked", () => {
-    // Write a file, snapshot it, then delete and recreate as different type
-    const tmp = join(tmpdir(), `tdd-dedup-${Date.now()}`);
-    mkdirSync(tmp, { recursive: true });
-    try {
-      initGit(tmp);
-      writeFileSync(join(tmp, "file.txt"), "original", "utf-8");
-      snapshot(tmp, "red");
-      // Delete tracked file — it's now a deletion (modified)
-      rmSync(join(tmp, "file.txt"));
-      // Recreate as untracked with same name
-      writeFileSync(join(tmp, "file.txt"), "new content", "utf-8");
-      const changes = changesSinceSnapshot(tmp);
-      // Should appear exactly once despite matching both conditions
-      const count = changes.filter((f) => f === "file.txt").length;
-      expect(count).toBe(1);
-    } finally {
-      rmSync(tmp, { recursive: true, force: true });
-    }
+    outputs["diff --name-only HEAD"] = "file.txt\n";
+    outputs["ls-files --others --exclude-standard"] = "file.txt\n";
+    const changes = changesSinceSnapshot("/test", deps);
+    const count = changes.filter((f) => f === "file.txt").length;
+    expect(count).toBe(1);
   });
 
   it("restoreFilesTo does nothing when files list is empty", () => {
-    // Should not throw
-    expect(() => restoreFilesTo(testDir, [])).not.toThrow();
+    expect(() => restoreFilesTo("/test", [], undefined, deps)).not.toThrow();
+    expect(deps.execSync).not.toHaveBeenCalled();
   });
-});
 
-// ── Isolated tests for untested git functions ────────────────────────────────
+  it("initGit force-adds TDD config files to bypass worktree gitignore", () => {
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/") && !p.endsWith(".git"),
+    );
+    initGit("/test", deps);
+    const call = (deps.execSync as any).mock.calls.find(
+      (c: any[]) => c[0].includes("git add -f"),
+    );
+    expect(call).toBeDefined();
+    expect(call[0]).toContain(".pi/tdd/state.json");
+    expect(call[0]).toContain(".pi/tdd/rules.json");
+    expect(call[0]).toContain(".pi/tdd/.gitignore");
+    expect(call[0]).not.toContain("tdd.log");
+    // Isolation: all git commands target the private repo, not the main project .git
+    expect(call[1].env.GIT_DIR).toBe("/test/.pi/tdd/.git");
+    expect(call[1].env.GIT_WORK_TREE).toBe("/test");
+  });
 
-function withTempDir(fn: (dir: string) => void) {
-  const dir = join(tmpdir(), `tdd-git-extra-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  try {
-    fn(dir);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}
+  it("initGit force-adds after add -A and before commit", () => {
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/") && !p.endsWith(".git"),
+    );
+    initGit("/test", deps);
+    const calls = (deps.execSync as any).mock.calls.map((c: any[]) => c[0]);
+    const addAIndex = calls.findIndex((c: string) => c.includes("git add -A "));
+    const forceAddIndex = calls.findIndex((c: string) => c.includes("git add -f"));
+    const commitIndex = calls.findIndex((c: string) => c.includes("git commit"));
+    expect(addAIndex).toBeLessThan(forceAddIndex);
+    expect(forceAddIndex).toBeLessThan(commitIndex);
+  });
+
+  it("snapshot force-adds state.json, rules.json, .gitignore", () => {
+    outputs["rev-parse HEAD"] = "hash123\n";
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/state.json") ||
+        p.includes(".pi/tdd/rules.json") ||
+        p.includes(".pi/tdd/.gitignore"),
+    );
+    snapshot("/test", "green", deps);
+    const call = (deps.execSync as any).mock.calls.find(
+      (c: any[]) => c[0].includes("git add -f"),
+    );
+    expect(call).toBeDefined();
+    expect(call[0]).toContain(".pi/tdd/state.json");
+    expect(call[0]).toContain(".pi/tdd/rules.json");
+    expect(call[0]).toContain(".pi/tdd/.gitignore");
+    expect(call[0]).not.toContain("tdd.log");
+    // Isolation: all git commands target the private repo, not the main project .git
+    expect(call[1].env.GIT_DIR).toBe("/test/.pi/tdd/.git");
+    expect(call[1].env.GIT_WORK_TREE).toBe("/test");
+  });
+
+  it("snapshot force-adds after add -A and before commit", () => {
+    outputs["rev-parse HEAD"] = "hash456\n";
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/state.json") ||
+        p.includes(".pi/tdd/rules.json") ||
+        p.includes(".pi/tdd/.gitignore"),
+    );
+    snapshot("/test", "red", deps);
+    const calls = (deps.execSync as any).mock.calls.map((c: any[]) => c[0]);
+    const addAIndex = calls.findIndex((c: string) => c.includes("git add -A "));
+    const forceAddIndex = calls.findIndex((c: string) => c.includes("git add -f"));
+    const commitIndex = calls.findIndex((c: string) => c.includes("git commit"));
+    expect(addAIndex).toBeLessThan(forceAddIndex);
+    expect(forceAddIndex).toBeLessThan(commitIndex);
+  });
+});
 
 describe("headMessage", () => {
-  it("returns init commit message after initGit", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      expect(headMessage(dir)).toBe("tdd: init");
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
     });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
+  it("returns init commit message after initGit", () => {
+    outputs["log -1 --format=%s HEAD"] = "tdd: init\n";
+    expect(headMessage("/test", deps)).toBe("tdd: init");
   });
 
   it("returns snapshot phase in commit message", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "green");
-      expect(headMessage(dir)).toBe("tdd: green");
-    });
+    outputs["log -1 --format=%s HEAD"] = "tdd: green\n";
+    expect(headMessage("/test", deps)).toBe("tdd: green");
   });
 
   it("updates after each snapshot", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      expect(headMessage(dir)).toBe("tdd: red");
-      snapshot(dir, "green");
-      expect(headMessage(dir)).toBe("tdd: green");
-      snapshot(dir, "refactor");
-      expect(headMessage(dir)).toBe("tdd: refactor");
-    });
+    outputs["rev-parse HEAD"] = "hash1\n";
+    snapshot("/test", "red", deps);
+    outputs["rev-parse HEAD"] = "hash2\n";
+    snapshot("/test", "green", deps);
+    outputs["log -1 --format=%s HEAD"] = "tdd: green\n";
+    expect(headMessage("/test", deps)).toBe("tdd: green");
   });
 });
 
 describe("hasParent", () => {
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
+    });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
   it("returns false when only init commit exists", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      expect(hasParent(dir)).toBe(false);
+    const mockExecSync = vi.fn((cmd: string) => {
+      if (cmd.includes("rev-parse HEAD~1")) throw new Error("unknown revision");
+      return Buffer.from("");
     });
+    deps = { ...deps, execSync: mockExecSync as any };
+    expect(hasParent("/test", deps)).toBe(false);
   });
 
   it("returns true after first snapshot", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      expect(hasParent(dir)).toBe(true);
+    const mockExecSync = vi.fn((cmd: string) => {
+      if (cmd.includes("rev-parse HEAD~1")) return Buffer.from("abc123\n");
+      return Buffer.from("");
     });
+    deps = { ...deps, execSync: mockExecSync as any };
+    expect(hasParent("/test", deps)).toBe(true);
   });
 
   it("returns true after multiple snapshots", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      snapshot(dir, "green");
-      snapshot(dir, "refactor");
-      expect(hasParent(dir)).toBe(true);
+    const mockExecSync = vi.fn((cmd: string) => {
+      if (cmd.includes("rev-parse HEAD~1")) return Buffer.from("abc123\n");
+      return Buffer.from("");
     });
+    deps = { ...deps, execSync: mockExecSync as any };
+    expect(hasParent("/test", deps)).toBe(true);
   });
 
   it("returns false after popping all snapshots back to init", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      expect(hasParent(dir)).toBe(true);
-      undoLastCommit(dir);
-      expect(hasParent(dir)).toBe(false);
+    let headExists = true;
+    const mockExecSync = vi.fn((cmd: string) => {
+      if (cmd.includes("rev-parse HEAD~1")) {
+        if (!headExists) throw new Error("unknown revision");
+        return Buffer.from("abc123\n");
+      }
+      if (cmd.includes("reset --soft HEAD~1")) {
+        headExists = false;
+        return Buffer.from("");
+      }
+      return Buffer.from("");
     });
+    deps = { ...deps, execSync: mockExecSync as any };
+
+    expect(hasParent("/test", deps)).toBe(true);
+    undoLastCommit("/test", deps);
+    expect(hasParent("/test", deps)).toBe(false);
   });
 });
 
 describe("resetHard", () => {
-  it("discards uncommitted changes", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      writeFileSync(join(dir, "file.txt"), "original", "utf-8");
-      snapshot(dir, "red");
-      writeFileSync(join(dir, "file.txt"), "dirty", "utf-8");
-      resetHard(dir);
-      expect(readFileSync(join(dir, "file.txt"), "utf-8")).toBe("original");
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
     });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
+  it("discards uncommitted changes", () => {
+    resetHard("/test", deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git reset --hard"),
+      expect.any(Object),
+    );
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git clean -fd"),
+      expect.any(Object),
+    );
   });
 
   it("discards untracked files", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      writeFileSync(join(dir, "scratch.txt"), "should vanish", "utf-8");
-      resetHard(dir);
-      expect(existsSync(join(dir, "scratch.txt"))).toBe(false);
-    });
+    resetHard("/test", deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git clean -fd"),
+      expect.any(Object),
+    );
   });
 
   it("leaves committed changes intact", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      writeFileSync(join(dir, "stays.txt"), "persists", "utf-8");
-      snapshot(dir, "red");
-      resetHard(dir);
-      expect(existsSync(join(dir, "stays.txt"))).toBe(true);
-      expect(readFileSync(join(dir, "stays.txt"), "utf-8")).toBe("persists");
-    });
+    resetHard("/test", deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git reset --hard"),
+      expect.any(Object),
+    );
   });
 
   it("does not throw when working tree matches HEAD", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      writeFileSync(join(dir, "file.txt"), "content", "utf-8");
-      snapshot(dir, "red");
-      expect(() => resetHard(dir)).not.toThrow();
-    });
+    expect(() => resetHard("/test", deps)).not.toThrow();
   });
 });
 
 describe("undoLastCommit", () => {
-  it("removes last commit and keeps its content as unstaged changes", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      writeFileSync(join(dir, "file.txt"), "v1", "utf-8");
-      snapshot(dir, "red");
-      writeFileSync(join(dir, "file.txt"), "v2", "utf-8");
-      snapshot(dir, "green");
-
-      // No uncommitted changes before undo
-      const before = changesSinceSnapshot(dir);
-      expect(before).toHaveLength(0);
-
-      undoLastCommit(dir);
-
-      // HEAD is now red snapshot (v1), but WT still has v2
-      expect(headMessage(dir)).toBe("tdd: red");
-      expect(modifiedFiles(dir)).toContain("file.txt");
-      expect(readFileSync(join(dir, "file.txt"), "utf-8")).toBe("v2");
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
     });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
+  it("removes last commit and keeps its content as unstaged changes", () => {
+    outputs["rev-parse HEAD"] = "hash1\n";
+    snapshot("/test", "red", deps);
+    outputs["rev-parse HEAD"] = "hash2\n";
+    snapshot("/test", "green", deps);
+
+    undoLastCommit("/test", deps);
+    expect(deps.execSync).toHaveBeenCalledWith(
+      expect.stringContaining("git reset --soft HEAD~1"),
+      expect.any(Object),
+    );
+
+    outputs["diff --name-only HEAD"] = "file.txt\n";
+    expect(modifiedFiles("/test", deps)).toContain("file.txt");
   });
 
   it("exposes popped content — new file stays in working tree and index", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      snapshot(dir, "red");
-      writeFileSync(join(dir, "new.txt"), "added in green", "utf-8");
-      snapshot(dir, "green");
+    outputs["rev-parse HEAD"] = "hash1\n";
+    snapshot("/test", "red", deps);
+    outputs["rev-parse HEAD"] = "hash2\n";
+    snapshot("/test", "green", deps);
 
-      expect(changesSinceSnapshot(dir)).toHaveLength(0);
+    undoLastCommit("/test", deps);
 
-      undoLastCommit(dir);
+    outputs["diff --name-only HEAD"] = "new.txt\n";
+    outputs["ls-files --others --exclude-standard"] = "";
+    expect(changesSinceSnapshot("/test", deps)).toContain("new.txt");
+  });
 
-      // git reset --soft preserves the index, so new.txt is still staged
-      // It shows as modified (added) against HEAD, not as untracked
-      expect(headMessage(dir)).toBe("tdd: red");
-      expect(changesSinceSnapshot(dir)).toContain("new.txt");
-      expect(readFileSync(join(dir, "new.txt"), "utf-8")).toBe("added in green");
+  it("errors when there is no parent commit", () => {
+    const mockExecSync = vi.fn((cmd: string) => {
+      if (cmd.includes("reset --soft HEAD~1")) throw new Error("unknown revision");
+      return Buffer.from("");
     });
+    deps = { ...deps, execSync: mockExecSync as any };
+    expect(() => undoLastCommit("/test", deps)).toThrow();
   });
+});
 
-  it("errors when there is no parent commit", () => {
-    withTempDir((dir) => {
-      initGit(dir);
-      expect(() => undoLastCommit(dir)).toThrow();
+describe("gitStashCreate", () => {
+  let deps: GitDeps;
+  let outputs: Record<string, string>;
+
+  function makeDeps(): GitDeps {
+    const mockExecSync = vi.fn((cmd: string) => {
+      for (const [prefix, out] of Object.entries(outputs)) {
+        if (cmd.includes(prefix)) return Buffer.from(out);
+      }
+      return Buffer.from("");
     });
+    return {
+      execSync: mockExecSync as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  }
+
+  beforeEach(() => {
+    outputs = {};
+    deps = makeDeps();
+  });
+
+  it("returns a hash when tracked file is modified", () => {
+    outputs["stash create --include-untracked"] = "abc123\n";
+    const result = gitStashCreate("/test", deps);
+    expect(result).toBe("abc123");
+  });
+
+  it("returns HEAD when working tree is clean", () => {
+    outputs["stash create --include-untracked"] = "";
+    const result = gitStashCreate("/test", deps);
+    expect(result).toBe("HEAD");
+  });
+});
+
+describe("stageFiles", () => {
+  let deps: GitDeps;
+
+  beforeEach(() => {
+    deps = {
+      execSync: vi.fn(() => "") as any,
+      existsSync: vi.fn().mockReturnValue(false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      unlinkSync: vi.fn(),
+      rmSync: vi.fn(),
+    };
+  });
+
+  it("calls git add -f with provided files", () => {
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/state.json") || p.includes(".pi/tdd/rules.json"),
+    );
+    stageFiles("/test", [".pi/tdd/state.json", ".pi/tdd/rules.json"], deps);
+    const call = (deps.execSync as any).mock.calls[0];
+    const cmd = call[0] as string;
+    expect(cmd).toContain("git add -f");
+    expect(cmd).toContain(".pi/tdd/state.json");
+    expect(cmd).toContain(".pi/tdd/rules.json");
+    // Isolated from main project git
+    expect(call[1].env.GIT_DIR).toBe("/test/.pi/tdd/.git");
+    expect(call[1].env.GIT_WORK_TREE).toBe("/test");
+  });
+
+  it("skips files that don't exist", () => {
+    deps.existsSync = vi.fn().mockReturnValue(false);
+    stageFiles("/test", [".pi/tdd/state.json", ".pi/tdd/rules.json"], deps);
+    expect(deps.execSync).not.toHaveBeenCalled();
+  });
+
+  it("handles a single existing file when others don't exist", () => {
+    deps.existsSync = vi.fn().mockImplementation((p: string) =>
+      p.includes(".pi/tdd/state.json"),
+    );
+    stageFiles("/test", [".pi/tdd/state.json", ".pi/tdd/rules.json"], deps);
+    const call = (deps.execSync as any).mock.calls[0];
+    expect(call[0]).toContain(".pi/tdd/state.json");
+    expect(call[0]).not.toContain(".pi/tdd/rules.json");
   });
 });