tdd-enforcer 0.2.2 → 0.2.3

package/adapters/pi/helpers.test.ts

@@ -1,19 +1,6 @@
-import { describe, it, expect } from "vitest";
-import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
+import { describe, it, expect, beforeEach, vi } from "vitest";
 import { loadTddState } from "./helpers.js";
 
-function withTempDir(fn: (dir: string) => void) {
-  const dir = join(tmpdir(), `tdd-helpers-test-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  try {
-    fn(dir);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-}
-
 const validRules = {
   allowedRedPhaseFiles: ["tests/**/*.test.ts"],
   allowedGreenPhaseFiles: ["src/**/*.ts"],
@@ -27,189 +14,260 @@ const validPhase = {
 };
 
 describe("loadTddState", () => {
-  it("returns missing dir error when .pi/tdd does not exist", () => {
-    withTempDir((dir) => {
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(false);
-      expect(result.reason).toContain("Missing .pi/tdd/");
+  let mockExistsSync: ReturnType<typeof vi.fn>;
+  let mockLoadConfig: ReturnType<typeof vi.fn>;
+  let mockInitGit: ReturnType<typeof vi.fn>;
+  let mockLoadPhaseState: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockHeadMessage: ReturnType<typeof vi.fn>;
+  let mockNextPhase: ReturnType<typeof vi.fn>;
+  let mockStageFiles: ReturnType<typeof vi.fn>;
+
+  // Shared helper to simulate nextPhase behavior
+  const realNextPhase = (p: string) =>
+    p === "red"
+      ? "green"
+      : p === "green"
+        ? "refactor"
+        : p === "refactor"
+          ? "red"
+          : null;
+
+  function makeDeps(overrides = {}) {
+    return {
+      existsSync: mockExistsSync,
+      loadConfig: mockLoadConfig,
+      initGit: mockInitGit,
+      loadPhaseState: mockLoadPhaseState,
+      savePhaseState: mockSavePhaseState,
+      headMessage: mockHeadMessage,
+      nextPhase: mockNextPhase,
+      stageFiles: mockStageFiles,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: all setup valid
+    mockExistsSync = vi.fn().mockImplementation((path: string) => {
+      // Make .pi/tdd and rules.json exist by default
+      if (path.includes(".git")) return false;
+      if (path.includes(".pi/tdd")) return true;
+      return true;
     });
+    mockLoadConfig = vi.fn().mockReturnValue(validRules);
+    mockInitGit = vi.fn();
+    mockLoadPhaseState = vi.fn().mockReturnValue(validPhase);
+    mockSavePhaseState = vi.fn();
+    mockHeadMessage = vi.fn().mockReturnValue("tdd: red");
+    mockNextPhase = vi.fn().mockImplementation(realNextPhase);
+    mockStageFiles = vi.fn();
+  });
+
+  it("returns missing dir error when .pi/tdd does not exist", () => {
+    mockExistsSync.mockReturnValue(false);
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(false);
+    expect(result.reason).toContain("Missing .pi/tdd/");
   });
 
   it("returns missing rules.json error when only dir exists", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(false);
-      expect(result.reason).toContain("rules.json");
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("rules.json")) return false;
+      if (path.includes(".pi/tdd")) return true;
+      return false;
     });
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(false);
+    expect(result.reason).toContain("rules.json");
   });
 
   it("auto-creates state.json when missing (default RED disabled)", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.state.enabled).toBe(false);
-        expect(result.state.current).toBe("red");
-      }
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return false;
+      if (path.includes(".git")) return false;
+      return true;
+    });
+    mockHeadMessage.mockReturnValue("tdd: init");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(false);
+      expect(result.state.current).toBe("red");
+    }
+    expect(mockInitGit).toHaveBeenCalled();
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", {
+      enabled: false,
+      current: "red",
     });
   });
 
   it("auto-creates state.json when corrupted (recovers to default)", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(join(dir, ".pi", "tdd", "state.json"), "not json", "utf-8");
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.state.enabled).toBe(false);
-        expect(result.state.current).toBe("red");
-      }
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return true; // exists but corrupted
+      if (path.includes(".git")) return false;
+      return true;
+    });
+    mockLoadPhaseState.mockImplementation(() => {
+      throw new Error("corrupt");
     });
+    mockHeadMessage.mockReturnValue("tdd: init");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(false);
+      expect(result.state.current).toBe("red");
+    }
   });
 
   it("returns invalid rules.json error for malformed JSON", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        "not json",
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify(validPhase),
-        "utf-8",
-      );
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(false);
-      expect(result.reason).toContain("Invalid .pi/tdd/rules.json");
+    mockLoadConfig.mockImplementation(() => {
+      throw new Error("Unexpected token");
     });
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(false);
+    expect(result.reason).toContain("Invalid .pi/tdd/rules.json");
   });
 
   it("returns ok when state.json has enabled: false (callers check enabled)", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify({ enabled: false, current: "red" }),
-        "utf-8",
-      );
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.state.enabled).toBe(false);
-        expect(result.state.current).toBe("red");
-      }
-    });
+    mockLoadPhaseState.mockReturnValue({ enabled: false, current: "red" });
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(false);
+      expect(result.state.current).toBe("red");
+    }
   });
 
   it("returns ok with state and config when everything valid", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify(validPhase),
-        "utf-8",
-      );
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.state.current).toBe("red");
-        expect(result.state.enabled).toBe(true);
-        expect(result.config.testCommands).toEqual(["npm test"]);
-        expect(result.config.allowedRedPhaseFiles).toEqual(["tests/**/*.test.ts"]);
-      }
-    });
+    mockLoadPhaseState.mockReturnValue(validPhase);
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.current).toBe("red");
+      expect(result.state.enabled).toBe(true);
+      expect(result.config.testCommands).toEqual(["npm test"]);
+      expect(result.config.allowedRedPhaseFiles).toEqual([
+        "tests/**/*.test.ts",
+      ]);
+    }
   });
 
   it("auto-creates git repo when missing", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify(validPhase),
-        "utf-8",
-      );
+    let gitExists = false;
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes(".git")) return gitExists;
+      if (path.includes(".pi/tdd")) return true;
+      return true;
+    });
+    mockInitGit.mockImplementation(() => {
+      gitExists = true;
+    });
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    expect(mockInitGit).toHaveBeenCalled();
+  });
 
-      const gitDir = join(dir, ".pi", "tdd", ".git");
-      expect(existsSync(gitDir)).toBe(false);
+  it("handles multiple calls without error", () => {
+    const r1 = loadTddState("/test", makeDeps());
+    expect(r1.ok).toBe(true);
+    const r2 = loadTddState("/test", makeDeps());
+    expect(r2.ok).toBe(true);
+    expect(mockLoadConfig).toHaveBeenCalledTimes(2);
+  });
 
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
+  it("recovers from invalid current phase in state.json (auto-creates default)", () => {
+    mockLoadPhaseState.mockImplementation(() => {
+      throw new Error("invalid phase");
+    });
+    mockHeadMessage.mockReturnValue("tdd: init");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(false);
+      expect(result.state.current).toBe("red");
+    }
+  });
 
-      // Git should now exist — loadTddState heals it
-      expect(existsSync(gitDir)).toBe(true);
+  it("recoverState: HEAD tdd:red → enabled green", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return false; // missing → triggers recover
+      return true;
     });
+    mockHeadMessage.mockReturnValue("tdd: red");
+    mockNextPhase.mockImplementation(realNextPhase);
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(true);
+      expect(result.state.current).toBe("green");
+    }
   });
 
-  it("handles multiple calls without error", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify(validPhase),
-        "utf-8",
-      );
+  it("recoverState: HEAD tdd:green → enabled refactor", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return false;
+      return true;
+    });
+    mockHeadMessage.mockReturnValue("tdd: green");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(true);
+      expect(result.state.current).toBe("refactor");
+    }
+  });
 
-      const r1 = loadTddState(dir);
-      expect(r1.ok).toBe(true);
+  it("recoverState: HEAD tdd:refactor → enabled red", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return false;
+      return true;
+    });
+    mockHeadMessage.mockReturnValue("tdd: refactor");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.state.enabled).toBe(true);
+      expect(result.state.current).toBe("red");
+    }
+  });
 
-      const r2 = loadTddState(dir);
-      expect(r2.ok).toBe(true);
+  it("force-adds state.json after creating it from recovery", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return false; // missing → triggers create
+      if (path.includes(".git")) return false;
+      return true;
     });
+    mockHeadMessage.mockReturnValue("tdd: init");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    expect(mockStageFiles).toHaveBeenCalledWith("/test", [".pi/tdd/state.json"]);
   });
 
-  it("recovers from invalid current phase in state.json (auto-creates default)", () => {
-    withTempDir((dir) => {
-      mkdirSync(join(dir, ".pi", "tdd"), { recursive: true });
-      writeFileSync(
-        join(dir, ".pi", "tdd", "rules.json"),
-        JSON.stringify(validRules),
-        "utf-8",
-      );
-      writeFileSync(
-        join(dir, ".pi", "tdd", "state.json"),
-        JSON.stringify({ enabled: true, current: "blurple" }),
-        "utf-8",
-      );
-      const result = loadTddState(dir);
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.state.enabled).toBe(false);
-        expect(result.state.current).toBe("red");
-      }
+  it("does not force-add state.json when it already exists and is valid", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return true;
+      if (path.includes(".git")) return true;
+      return true;
+    });
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    expect(mockStageFiles).not.toHaveBeenCalled();
+  });
+
+  it("force-adds state.json after recovering from corrupted state", () => {
+    mockExistsSync.mockImplementation((path: string) => {
+      if (path.includes("state.json")) return true; // exists but corrupted
+      if (path.includes(".git")) return true;
+      return true;
+    });
+    mockLoadPhaseState.mockImplementation(() => {
+      throw new Error("corrupt");
     });
+    mockHeadMessage.mockReturnValue("tdd: init");
+    const result = loadTddState("/test", makeDeps());
+    expect(result.ok).toBe(true);
+    expect(mockStageFiles).toHaveBeenCalledWith("/test", [".pi/tdd/state.json"]);
   });
 });

package/adapters/pi/helpers.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { loadPhaseState, savePhaseState, loadConfig, headMessage, nextPhase, initGit } from "../../engine/index.js";
+import { loadPhaseState, savePhaseState, loadConfig, headMessage, nextPhase, initGit, stageFiles } from "../../engine/index.js";
 import type { PhaseState, Config, Phase } from "../../engine/types.js";
 
 export type TddLoadResult =
@@ -11,18 +11,29 @@ export type TddLoadResult =
  * Recover state.json from private git HEAD, or create default.
  * Returns the state (does not save to disk — caller does that).
  */
-function recoverState(root: string, tddDir: string): PhaseState {
+function recoverState(
+  root: string,
+  tddDir: string,
+  deps: {
+    existsSync: typeof existsSync;
+    headMessage: typeof headMessage;
+    nextPhase: typeof nextPhase;
+  } = { existsSync, headMessage, nextPhase },
+): PhaseState {
   const gitDir = join(tddDir, ".git");
-  if (existsSync(gitDir)) {
+  if (deps.existsSync(gitDir)) {
     try {
-      const msg = headMessage(root);
+      const msg = deps.headMessage(root);
       const m = msg.match(/^tdd: (red|green|refactor|init)$/);
       if (m) {
-        const headPhase = m[1] as Phase;
-        if (headPhase === "init") {
+        const label = m[1];
+        if (label === "init") {
           return { enabled: false, current: "red" };
         }
-        const next = nextPhase(headPhase);
+        if (label !== "red" && label !== "green" && label !== "refactor") {
+          return { enabled: false, current: "red" };
+        }
+        const next = deps.nextPhase(label);
         return { enabled: true, current: next ?? "red" };
       }
     } catch {
@@ -40,29 +51,50 @@ function recoverState(root: string, tddDir: string): PhaseState {
  *
  * Callers must check state.enabled themselves if they need active enforcement.
  */
-export function loadTddState(root: string): TddLoadResult {
+export function loadTddState(
+  root: string,
+  deps: {
+    existsSync: typeof existsSync;
+    loadConfig: typeof loadConfig;
+    initGit: typeof initGit;
+    loadPhaseState: typeof loadPhaseState;
+    savePhaseState: typeof savePhaseState;
+    headMessage: typeof headMessage;
+    nextPhase: typeof nextPhase;
+    stageFiles: typeof stageFiles;
+  } = {
+    existsSync,
+    loadConfig,
+    initGit,
+    loadPhaseState,
+    savePhaseState,
+    headMessage,
+    nextPhase,
+    stageFiles,
+  },
+): TddLoadResult {
   const tddDir = join(root, ".pi", "tdd");
-  if (!existsSync(tddDir)) {
+  if (!deps.existsSync(tddDir)) {
     return { ok: false, reason: "Missing .pi/tdd/ directory. See the tdd-enforcer skill to learn how to set up TDD configs." };
   }
 
   const rulesPath = join(tddDir, "rules.json");
-  if (!existsSync(rulesPath)) {
+  if (!deps.existsSync(rulesPath)) {
     return { ok: false, reason: "Missing .pi/tdd/rules.json. See the tdd-enforcer skill to learn how to set up TDD configs." };
   }
 
   let config: Config;
   try {
-    config = loadConfig(root);
+    config = deps.loadConfig(root);
   } catch (e) {
     return { ok: false, reason: `Invalid .pi/tdd/rules.json: ${(e as Error).message}. See the tdd-enforcer skill.` };
   }
 
   // Init git if missing — required for state recovery and all consumers
   const gitDir = join(tddDir, ".git");
-  if (!existsSync(gitDir)) {
+  if (!deps.existsSync(gitDir)) {
     try {
-      initGit(root);
+      deps.initGit(root);
     } catch (e) {
       return { ok: false, reason: `Failed to initialise private git repo: ${(e as Error).message}` };
     }
@@ -71,16 +103,17 @@ export function loadTddState(root: string): TddLoadResult {
   // Auto-create state.json if missing or corrupted
   const phasePath = join(tddDir, "state.json");
   let state: PhaseState | undefined;
-  if (existsSync(phasePath)) {
+  if (deps.existsSync(phasePath)) {
     try {
-      state = loadPhaseState(root);
+      state = deps.loadPhaseState(root);
     } catch {
       // Corrupted — recover below
     }
   }
   if (!state) {
-    state = recoverState(root, tddDir);
-    savePhaseState(root, state);
+    state = recoverState(root, tddDir, { existsSync: deps.existsSync, headMessage: deps.headMessage, nextPhase: deps.nextPhase });
+    deps.savePhaseState(root, state);
+    deps.stageFiles(root, [".pi/tdd/state.json"]);
   }
 
   return { ok: true, state, config };