tdd-enforcer 0.2.5 → 0.2.7

package/engine/state.ts

@@ -1,38 +1,40 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import type { PhaseState } from "./types.js";
 
 const TDD_DIR = ".pi/tdd";
 const VALID_PHASES = new Set(["red", "green", "refactor"]);
 
 export function phaseStatePath(projectRoot: string): string {
-  return join(projectRoot, TDD_DIR, "state.json");
+	return join(projectRoot, TDD_DIR, "state.json");
 }
 
 function ensureDir(path: string): void {
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+	const dir = dirname(path);
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
 }
 
 export function loadPhaseState(projectRoot: string): PhaseState {
-  const path = phaseStatePath(projectRoot);
-  const raw = readFileSync(path, "utf-8");
-  const parsed = JSON.parse(raw) as PhaseState;
+	const path = phaseStatePath(projectRoot);
+	const raw = readFileSync(path, "utf-8");
+	const parsed = JSON.parse(raw) as PhaseState;
 
-  if (typeof parsed.current !== "string" || !VALID_PHASES.has(parsed.current)) {
-    throw new Error(`state.json: invalid phase "${String(parsed.current)}". Must be red, green, or refactor.`);
-  }
+	if (typeof parsed.current !== "string" || !VALID_PHASES.has(parsed.current)) {
+		throw new Error(
+			`state.json: invalid phase "${String(parsed.current)}". Must be red, green, or refactor.`,
+		);
+	}
 
-  return {
-    enabled: parsed.enabled === true,
-    current: parsed.current,
-  };
+	return {
+		enabled: parsed.enabled === true,
+		current: parsed.current,
+	};
 }
 
 export function savePhaseState(projectRoot: string, state: PhaseState): void {
-  const path = phaseStatePath(projectRoot);
-  ensureDir(path);
-  writeFileSync(path, JSON.stringify(state, null, 2), "utf-8");
+	const path = phaseStatePath(projectRoot);
+	ensureDir(path);
+	writeFileSync(path, JSON.stringify(state, null, 2), "utf-8");
 }

package/engine/transition.test.ts

@@ -1,206 +1,258 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { getDisallowedChanges, nextPhase, checkGate } from "./transition.js";
-import type { Config, TestRunner } from "./types.js";
 import picomatch from "picomatch";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { checkGate, getDisallowedChanges, nextPhase } from "./transition.js";
+import type { Config, TestRunner } from "./types.js";
 
 // ── Pure unit tests: nextPhase ──────────────────────────────────────────────
 
 describe("nextPhase", () => {
-  it("returns green from red", () => {
-    expect(nextPhase("red")).toBe("green");
-  });
+	it("returns green from red", () => {
+		expect(nextPhase("red")).toBe("green");
+	});
 
-  it("returns refactor from green", () => {
-    expect(nextPhase("green")).toBe("refactor");
-  });
+	it("returns refactor from green", () => {
+		expect(nextPhase("green")).toBe("refactor");
+	});
 
-  it("returns red from refactor", () => {
-    expect(nextPhase("refactor")).toBe("red");
-  });
+	it("returns red from refactor", () => {
+		expect(nextPhase("refactor")).toBe("red");
+	});
 
-  it("returns null for unknown phase", () => {
-    expect(nextPhase("blurple" as any)).toBeNull();
-  });
+	it("returns null for unknown phase", () => {
+		expect(nextPhase("blurple" as any)).toBeNull();
+	});
 });
 
 // ── Pure unit tests: checkGate ──────────────────────────────────────────────
 
 function makeRunner(passed: boolean): TestRunner {
-  return async (_cmds, _timeout) => ({
-    passed,
-    message: passed ? "all ok" : "tests failed",
-  });
+	return async (_cmds, _timeout) => ({
+		passed,
+		message: passed ? "all ok" : "tests failed",
+	});
 }
 
 const testConfig: Config = {
-  blockedInRed: [],
-  blockedInGreen: [],
-  testCommands: ["npm test"],
-  timeoutSeconds: 30,
+	blockedInRed: [],
+	blockedInGreen: [],
+	testCommands: ["npm test"],
+	timeoutSeconds: 30,
 };
 
 describe("checkGate", () => {
+	describe("red → green (tests must fail)", () => {
+		it("allows when tests fail", async () => {
+			const r = await checkGate("red", "green", makeRunner(false), testConfig);
+			expect(r.passed).toBe(true);
+			expect(r.message).toMatch(/proceed|fail/i);
+		});
+
+		it("blocks when tests pass", async () => {
+			const r = await checkGate("red", "green", makeRunner(true), testConfig);
+			expect(r.passed).toBe(false);
+			expect(r.message).toMatch(/transitioning to GREEN/i);
+		});
+	});
+
+	describe("green → refactor (tests must pass)", () => {
+		it("allows when tests pass", async () => {
+			const r = await checkGate(
+				"green",
+				"refactor",
+				makeRunner(true),
+				testConfig,
+			);
+			expect(r.passed).toBe(true);
+			expect(r.message).toMatch(/pass/i);
+		});
+
+		it("blocks when tests fail", async () => {
+			const r = await checkGate(
+				"green",
+				"refactor",
+				makeRunner(false),
+				testConfig,
+			);
+			expect(r.passed).toBe(false);
+			expect(r.message).toMatch(/transitioning to REFACTOR/i);
+		});
+	});
+
+	describe("refactor → red (tests must pass)", () => {
+		it("allows when tests pass", async () => {
+			const r = await checkGate(
+				"refactor",
+				"red",
+				makeRunner(true),
+				testConfig,
+			);
+			expect(r.passed).toBe(true);
+			expect(r.message).toMatch(/pass/i);
+		});
+
+		it("blocks when tests fail", async () => {
+			const r = await checkGate(
+				"refactor",
+				"red",
+				makeRunner(false),
+				testConfig,
+			);
+			expect(r.passed).toBe(false);
+			expect(r.message).toMatch(/transitioning to RED/i);
+		});
+	});
+
+	it("passes test commands to the runner", async () => {
+		let captured: string[] | undefined;
+		const runner: TestRunner = async (cmds) => {
+			captured = cmds;
+			return { passed: true, message: "" };
+		};
+		await checkGate("red", "green", runner, testConfig);
+		expect(captured).toEqual(["npm test"]);
+	});
 
-  describe("red → green (tests must fail)", () => {
-    it("allows when tests fail", async () => {
-      const r = await checkGate("red", "green", makeRunner(false), testConfig);
-      expect(r.passed).toBe(true);
-      expect(r.message).toMatch(/proceed|fail/i);
-    });
-
-    it("blocks when tests pass", async () => {
-      const r = await checkGate("red", "green", makeRunner(true), testConfig);
-      expect(r.passed).toBe(false);
-      expect(r.message).toMatch(/transitioning to GREEN/i);
-    });
-  });
-
-  describe("green → refactor (tests must pass)", () => {
-    it("allows when tests pass", async () => {
-      const r = await checkGate("green", "refactor", makeRunner(true), testConfig);
-      expect(r.passed).toBe(true);
-      expect(r.message).toMatch(/pass/i);
-    });
-
-    it("blocks when tests fail", async () => {
-      const r = await checkGate("green", "refactor", makeRunner(false), testConfig);
-      expect(r.passed).toBe(false);
-      expect(r.message).toMatch(/transitioning to REFACTOR/i);
-    });
-  });
-
-  describe("refactor → red (tests must pass)", () => {
-    it("allows when tests pass", async () => {
-      const r = await checkGate("refactor", "red", makeRunner(true), testConfig);
-      expect(r.passed).toBe(true);
-      expect(r.message).toMatch(/pass/i);
-    });
-
-    it("blocks when tests fail", async () => {
-      const r = await checkGate("refactor", "red", makeRunner(false), testConfig);
-      expect(r.passed).toBe(false);
-      expect(r.message).toMatch(/transitioning to RED/i);
-    });
-  });
-
-
-  it("passes test commands to the runner", async () => {
-    let captured: string[] | undefined;
-    const runner: TestRunner = async (cmds) => {
-      captured = cmds;
-      return { passed: true, message: "" };
-    };
-    await checkGate("red", "green", runner, testConfig);
-    expect(captured).toEqual(["npm test"]);
-  });
-
-  it("passes timeoutSeconds to the runner", async () => {
-    let captured: number | undefined;
-    const runner: TestRunner = async (_cmds, t) => {
-      captured = t;
-      return { passed: true, message: "" };
-    };
-    await checkGate("red", "green", runner, testConfig);
-    expect(captured).toBe(30);
-  });
-
-  it("passes multiple test commands to the runner", async () => {
-    const multiConfig: Config = {
-      ...testConfig,
-      testCommands: ["npm run test:unit", "npm run test:integration"],
-    };
-    let captured: string[] | undefined;
-    const runner: TestRunner = async (cmds) => {
-      captured = cmds;
-      return { passed: true, message: "" };
-    };
-    await checkGate("red", "green", runner, multiConfig);
-    expect(captured).toHaveLength(2);
-    expect(captured).toContain("npm run test:unit");
-    expect(captured).toContain("npm run test:integration");
-  });
+	it("passes timeoutSeconds to the runner", async () => {
+		let captured: number | undefined;
+		const runner: TestRunner = async (_cmds, t) => {
+			captured = t;
+			return { passed: true, message: "" };
+		};
+		await checkGate("red", "green", runner, testConfig);
+		expect(captured).toBe(30);
+	});
+
+	it("passes multiple test commands to the runner", async () => {
+		const multiConfig: Config = {
+			...testConfig,
+			testCommands: ["npm run test:unit", "npm run test:integration"],
+		};
+		let captured: string[] | undefined;
+		const runner: TestRunner = async (cmds) => {
+			captured = cmds;
+			return { passed: true, message: "" };
+		};
+		await checkGate("red", "green", runner, multiConfig);
+		expect(captured).toHaveLength(2);
+		expect(captured).toContain("npm run test:unit");
+		expect(captured).toContain("npm run test:integration");
+	});
 });
 
 // ── Pure unit tests: getDisallowedChanges ────────────────────────────────────
 
 const denyConfig: Config = {
-  blockedInRed: ["src/**/*.ts"],
-  blockedInGreen: ["tests/**/*.test.ts"],
-  testCommands: [],
-  timeoutSeconds: 30,
+	blockedInRed: ["src/**/*.ts"],
+	blockedInGreen: ["tests/**/*.test.ts"],
+	testCommands: [],
+	timeoutSeconds: 30,
 };
 
 describe("getDisallowedChanges", () => {
-  let mockChangesSinceSnapshot: ReturnType<typeof vi.fn>;
-  let mockDisallowedFiles: ReturnType<typeof vi.fn>;
-
-  function makeDeps(overrides = {}) {
-    return {
-      changesSinceSnapshot: mockChangesSinceSnapshot,
-      disallowedFiles: mockDisallowedFiles,
-      ...overrides,
-    };
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockChangesSinceSnapshot = vi.fn().mockReturnValue([]);
-    mockDisallowedFiles = vi.fn().mockReturnValue([]);
-  });
-
-  it("returns empty for refactor phase regardless of git state", () => {
-    const result = getDisallowedChanges("/any", "refactor", denyConfig, makeDeps());
-    expect(result).toEqual([]);
-    expect(mockChangesSinceSnapshot).not.toHaveBeenCalled();
-  });
-
-  it("returns empty when no files changed", () => {
-    mockChangesSinceSnapshot.mockReturnValue([]);
-    const result = getDisallowedChanges("/test", "red", denyConfig, makeDeps());
-    expect(result).toEqual([]);
-    expect(mockChangesSinceSnapshot).toHaveBeenCalledWith("/test");
-  });
-
-  it("returns disallowed files in red phase", () => {
-    mockChangesSinceSnapshot.mockReturnValue(["src/main.ts", "tests/foo.test.ts", "README.md"]);
-    const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
-    mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
-      if (phase === "red") {
-        return changed.filter((f: string) => matchBlockedInRed(f));
-      }
-      return [];
-    });
-    const violations = getDisallowedChanges("/test", "red", denyConfig, makeDeps());
-    expect(violations).toContain("src/main.ts");
-    expect(violations).not.toContain("tests/foo.test.ts");
-    expect(violations).not.toContain("README.md");
-  });
-
-  it("returns disallowed files in green phase", () => {
-    mockChangesSinceSnapshot.mockReturnValue(["tests/foo.test.ts", "src/main.ts", "package.json"]);
-    const matchBlockedInGreen = picomatch(denyConfig.blockedInGreen);
-    mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
-      if (phase === "green") {
-        return changed.filter((f: string) => matchBlockedInGreen(f));
-      }
-      return [];
-    });
-    const violations = getDisallowedChanges("/test", "green", denyConfig, makeDeps());
-    expect(violations).toContain("tests/foo.test.ts");
-    expect(violations).not.toContain("src/main.ts");
-    expect(violations).not.toContain("package.json");
-  });
-
-  it("catches untracked files, not just modified", () => {
-    mockChangesSinceSnapshot.mockReturnValue(["src/new.ts"]);
-    const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
-    mockDisallowedFiles.mockImplementation((changed: string[], phase: string) => {
-      if (phase === "red") {
-        return changed.filter((f: string) => matchBlockedInRed(f));
-      }
-      return [];
-    });
-    const violations = getDisallowedChanges("/test", "red", denyConfig, makeDeps());
-    expect(violations).toContain("src/new.ts");
-  });
+	let mockChangesSinceSnapshot: ReturnType<typeof vi.fn>;
+	let mockDisallowedFiles: ReturnType<typeof vi.fn>;
+
+	function makeDeps(overrides = {}) {
+		return {
+			changesSinceSnapshot: mockChangesSinceSnapshot,
+			disallowedFiles: mockDisallowedFiles,
+			...overrides,
+		};
+	}
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockChangesSinceSnapshot = vi.fn().mockReturnValue([]);
+		mockDisallowedFiles = vi.fn().mockReturnValue([]);
+	});
+
+	it("returns empty for refactor phase regardless of git state", () => {
+		const result = getDisallowedChanges(
+			"/any",
+			"refactor",
+			denyConfig,
+			makeDeps(),
+		);
+		expect(result).toEqual([]);
+		expect(mockChangesSinceSnapshot).not.toHaveBeenCalled();
+	});
+
+	it("returns empty when no files changed", () => {
+		mockChangesSinceSnapshot.mockReturnValue([]);
+		const result = getDisallowedChanges("/test", "red", denyConfig, makeDeps());
+		expect(result).toEqual([]);
+		expect(mockChangesSinceSnapshot).toHaveBeenCalledWith("/test");
+	});
+
+	it("returns disallowed files in red phase", () => {
+		mockChangesSinceSnapshot.mockReturnValue([
+			"src/main.ts",
+			"tests/foo.test.ts",
+			"README.md",
+		]);
+		const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
+		mockDisallowedFiles.mockImplementation(
+			(changed: string[], phase: string) => {
+				if (phase === "red") {
+					return changed.filter((f: string) => matchBlockedInRed(f));
+				}
+				return [];
+			},
+		);
+		const violations = getDisallowedChanges(
+			"/test",
+			"red",
+			denyConfig,
+			makeDeps(),
+		);
+		expect(violations).toContain("src/main.ts");
+		expect(violations).not.toContain("tests/foo.test.ts");
+		expect(violations).not.toContain("README.md");
+	});
+
+	it("returns disallowed files in green phase", () => {
+		mockChangesSinceSnapshot.mockReturnValue([
+			"tests/foo.test.ts",
+			"src/main.ts",
+			"package.json",
+		]);
+		const matchBlockedInGreen = picomatch(denyConfig.blockedInGreen);
+		mockDisallowedFiles.mockImplementation(
+			(changed: string[], phase: string) => {
+				if (phase === "green") {
+					return changed.filter((f: string) => matchBlockedInGreen(f));
+				}
+				return [];
+			},
+		);
+		const violations = getDisallowedChanges(
+			"/test",
+			"green",
+			denyConfig,
+			makeDeps(),
+		);
+		expect(violations).toContain("tests/foo.test.ts");
+		expect(violations).not.toContain("src/main.ts");
+		expect(violations).not.toContain("package.json");
+	});
+
+	it("catches untracked files, not just modified", () => {
+		mockChangesSinceSnapshot.mockReturnValue(["src/new.ts"]);
+		const matchBlockedInRed = picomatch(denyConfig.blockedInRed);
+		mockDisallowedFiles.mockImplementation(
+			(changed: string[], phase: string) => {
+				if (phase === "red") {
+					return changed.filter((f: string) => matchBlockedInRed(f));
+				}
+				return [];
+			},
+		);
+		const violations = getDisallowedChanges(
+			"/test",
+			"red",
+			denyConfig,
+			makeDeps(),
+		);
+		expect(violations).toContain("src/new.ts");
+	});
 });

package/engine/transition.ts

@@ -1,21 +1,24 @@
-import type { Phase, Config, Transition } from "./types.js";
-import { PHASE_CYCLE } from "./types.js";
-import { changesSinceSnapshot } from "./git.js";
 import { disallowedFiles } from "./enforce.js";
+import { changesSinceSnapshot } from "./git.js";
+import type { Config, Phase, Transition } from "./types.js";
+import { PHASE_CYCLE } from "./types.js";
 
 /**
  * Get the next phase in the cycle.
  */
 export function nextPhase(current: Phase): Phase | null {
-  return PHASE_CYCLE[current] ?? null;
+	return PHASE_CYCLE[current] ?? null;
 }
 
 export interface GateResult {
-  passed: boolean;
-  message: string;
+	passed: boolean;
+	message: string;
 }
 
-export type TestRunner = (commands: string[], timeoutSeconds: number) => Promise<GateResult>;
+export type TestRunner = (
+	commands: string[],
+	timeoutSeconds: number,
+) => Promise<GateResult>;
 
 /**
  * Run the transition gate check.
@@ -24,42 +27,42 @@ export type TestRunner = (commands: string[], timeoutSeconds: number) => Promise
  * - REFACTOR→RED: tests must pass (all zero exit)
  */
 export async function checkGate(
-  from: Phase,
-  to: Phase,
-  testRunner: TestRunner,
-  config: Config,
+	from: Phase,
+	to: Phase,
+	testRunner: TestRunner,
+	config: Config,
 ): Promise<GateResult> {
-  const result = await testRunner(config.testCommands, config.timeoutSeconds);
-
-  switch (`${from}→${to}` as Transition) {
-    case "red→green":
-      if (result.passed) {
-        return {
-          passed: false,
-          message: "Tests passed. Add a failing test before transitioning to GREEN.",
-        };
-      }
-      return { passed: true, message: "Tests fail — proceed to GREEN." };
+	const result = await testRunner(config.testCommands, config.timeoutSeconds);
 
-    case "green→refactor":
-      if (!result.passed) {
-        return {
-          passed: false,
-          message: "Tests failed. Fix them before transitioning to REFACTOR.",
-        };
-      }
-      return { passed: true, message: "All tests pass — proceeding." };
+	switch (`${from}→${to}` as Transition) {
+		case "red→green":
+			if (result.passed) {
+				return {
+					passed: false,
+					message:
+						"Tests passed. Add a failing test before transitioning to GREEN.",
+				};
+			}
+			return { passed: true, message: "Tests fail — proceed to GREEN." };
 
-    case "refactor→red":
-      if (!result.passed) {
-        return {
-          passed: false,
-          message: "Tests failed. Fix them before transitioning to RED.",
-        };
-      }
-      return { passed: true, message: "All tests pass — proceeding." };
+		case "green→refactor":
+			if (!result.passed) {
+				return {
+					passed: false,
+					message: "Tests failed. Fix them before transitioning to REFACTOR.",
+				};
+			}
+			return { passed: true, message: "All tests pass — proceeding." };
 
-  }
+		case "refactor→red":
+			if (!result.passed) {
+				return {
+					passed: false,
+					message: "Tests failed. Fix them before transitioning to RED.",
+				};
+			}
+			return { passed: true, message: "All tests pass — proceeding." };
+	}
 }
 
 /**
@@ -67,19 +70,19 @@ export async function checkGate(
  * Returns list of violating files (empty = ok).
  */
 export function getDisallowedChanges(
-  projectRoot: string,
-  phase: Phase,
-  config: Config,
-  deps: {
-    changesSinceSnapshot: typeof changesSinceSnapshot;
-    disallowedFiles: typeof disallowedFiles;
-  } = {
-    changesSinceSnapshot,
-    disallowedFiles,
-  },
+	projectRoot: string,
+	phase: Phase,
+	config: Config,
+	deps: {
+		changesSinceSnapshot: typeof changesSinceSnapshot;
+		disallowedFiles: typeof disallowedFiles;
+	} = {
+		changesSinceSnapshot,
+		disallowedFiles,
+	},
 ): string[] {
-  if (phase === "refactor") return [];
+	if (phase === "refactor") return [];
 
-  const changed = deps.changesSinceSnapshot(projectRoot);
-  return deps.disallowedFiles(changed, phase, config);
+	const changed = deps.changesSinceSnapshot(projectRoot);
+	return deps.disallowedFiles(changed, phase, config);
 }

package/engine/types.ts

@@ -1,21 +1,21 @@
 export type Phase = "red" | "green" | "refactor";
 
 export interface PhaseState {
-  enabled: boolean;
-  current: Phase;
+	enabled: boolean;
+	current: Phase;
 }
 
 export interface Config {
-  blockedInRed: string[];
-  blockedInGreen: string[];
-  testCommands: string[];
-  timeoutSeconds: number;
+	blockedInRed: string[];
+	blockedInGreen: string[];
+	testCommands: string[];
+	timeoutSeconds: number;
 }
 
 export type Transition = "red→green" | "green→refactor" | "refactor→red";
 
 export const PHASE_CYCLE: Record<Phase, Phase | null> = {
-  red: "green",
-  green: "refactor",
-  refactor: "red",
+	red: "green",
+	green: "refactor",
+	refactor: "red",
 };