tdd-enforcer 0.2.6 → 0.2.7

package/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [22, 24]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - run: npm ci
+
+      - run: npm run lint
+
+      - run: npm test

package/adapters/pi/helpers.test.ts

@@ -1,273 +1,275 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { loadTddState } from "./helpers.js";
 
 const validRules = {
-  blockedInRed: ["tests/**/*.test.ts"],
-  blockedInGreen: ["src/**/*.ts"],
-  testCommands: ["npm test"],
-  timeoutSeconds: 30,
+	blockedInRed: ["tests/**/*.test.ts"],
+	blockedInGreen: ["src/**/*.ts"],
+	testCommands: ["npm test"],
+	timeoutSeconds: 30,
 };
 
 const validPhase = {
-  enabled: true,
-  current: "red",
+	enabled: true,
+	current: "red",
 };
 
 describe("loadTddState", () => {
-  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>;
+	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;
+	// 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,
-    };
-  }
+	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();
-  });
+	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 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", () => {
-    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("returns missing rules.json error when only dir exists", () => {
+		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)", () => {
-    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 missing (default RED disabled)", () => {
+		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)", () => {
-    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("auto-creates state.json when corrupted (recovers to default)", () => {
+		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", () => {
-    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 invalid rules.json error for malformed 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)", () => {
-    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 when state.json has enabled: false (callers check enabled)", () => {
+		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", () => {
-    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.blockedInRed).toEqual([
-        "tests/**/*.test.ts",
-      ]);
-    }
-  });
+	it("returns ok with state and config when everything valid", () => {
+		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.blockedInRed).toEqual(["tests/**/*.test.ts"]);
+		}
+	});
 
-  it("auto-creates git repo when missing", () => {
-    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();
-  });
+	it("auto-creates git repo when missing", () => {
+		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();
+	});
 
-  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);
-  });
+	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);
+	});
 
-  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");
-    }
-  });
+	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");
+		}
+	});
 
-  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("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("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");
-    }
-  });
+	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");
+		}
+	});
 
-  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");
-    }
-  });
+	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");
+		}
+	});
 
-  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("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("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("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"]);
-  });
+	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",
+		]);
+	});
 });