tdd-enforcer 0.3.3 → 0.3.4

package/adapters/pi/helpers.test.ts

@@ -1,275 +0,0 @@
-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,
-};
-
-const validPhase = {
-	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>;
-
-	// 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", () => {
-		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 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 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("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("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: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("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("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,143 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import {
-	headMessage,
-	initGit,
-	loadConfig,
-	loadPhaseState,
-	nextPhase,
-	savePhaseState,
-	stageFiles,
-} from "../../engine/index.js";
-import type { Config, PhaseState } from "../../engine/types.js";
-
-export type TddLoadResult =
-	| { ok: true; state: PhaseState; config: Config }
-	| { ok: false; reason: string };
-
-/**
- * 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,
-	deps: {
-		existsSync: typeof existsSync;
-		headMessage: typeof headMessage;
-		nextPhase: typeof nextPhase;
-	} = { existsSync, headMessage, nextPhase },
-): PhaseState {
-	const gitDir = join(tddDir, ".git");
-	if (deps.existsSync(gitDir)) {
-		try {
-			const msg = deps.headMessage(root);
-			const m = msg.match(/^tdd: (red|green|refactor|init)$/);
-			if (m) {
-				const label = m[1];
-				if (label === "init") {
-					return { enabled: false, current: "red" };
-				}
-				const next = deps.nextPhase(label);
-				return { enabled: true, current: next ?? "red" };
-			}
-		} catch {
-			// No commits or bad HEAD — fall through to default
-		}
-	}
-	return { enabled: false, current: "red" };
-}
-
-/**
- * Load TDD state + config in one go.
- * Auto-creates state.json from private git HEAD when missing or corrupted.
- * Returns ok:true with state and config when rules.json is valid.
- * Returns ok:false with a specific reason string otherwise.
- *
- * Callers must check state.enabled themselves if they need active enforcement.
- */
-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 (!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 (!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 = 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 (!deps.existsSync(gitDir)) {
-		try {
-			deps.initGit(root);
-		} catch (e) {
-			return {
-				ok: false,
-				reason: `Failed to initialise private git repo: ${(e as Error).message}`,
-			};
-		}
-	}
-
-	// Auto-create state.json if missing or corrupted
-	const phasePath = join(tddDir, "state.json");
-	let state: PhaseState | undefined;
-	if (deps.existsSync(phasePath)) {
-		try {
-			state = deps.loadPhaseState(root);
-		} catch {
-			// Corrupted — recover below
-		}
-	}
-	if (!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 };
-}

package/adapters/pi/log.test.ts

@@ -1,95 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { tddLog } from "./log.js";
-
-describe("tddLog", () => {
-	let mockExistsSync: ReturnType<typeof vi.fn>;
-	let mockMkdirSync: ReturnType<typeof vi.fn>;
-	let mockAppendFileSync: ReturnType<typeof vi.fn>;
-	let mockWriteFileSync: ReturnType<typeof vi.fn>;
-	let mockReadFileSync: ReturnType<typeof vi.fn>;
-	let writtenContent: string;
-
-	function makeDeps() {
-		return {
-			existsSync: mockExistsSync,
-			mkdirSync: mockMkdirSync,
-			appendFileSync: mockAppendFileSync,
-			writeFileSync: mockWriteFileSync,
-			readFileSync: mockReadFileSync,
-		};
-	}
-
-	beforeEach(() => {
-		writtenContent = "";
-		mockExistsSync = vi.fn().mockReturnValue(true);
-		mockMkdirSync = vi.fn();
-		mockAppendFileSync = vi.fn((_path: string, content: string) => {
-			writtenContent += content;
-		});
-		mockWriteFileSync = vi.fn((_path: string, content: string) => {
-			writtenContent = content;
-		});
-		mockReadFileSync = vi.fn(() => writtenContent);
-	});
-
-	it("creates the log file if it doesn't exist", () => {
-		// readFileSync throws → outer catch silently swallows it
-		mockReadFileSync = vi.fn(() => {
-			throw new Error("ENOENT: no such file or directory");
-		});
-
-		tddLog("/tdd", "INFO", "hello", undefined, makeDeps());
-
-		expect(mockAppendFileSync).toHaveBeenCalled();
-		expect(mockAppendFileSync.mock.calls[0][1]).toContain("hello");
-	});
-
-	it("appends multiple lines", () => {
-		tddLog("/tdd", "INFO", "line one", undefined, makeDeps());
-		tddLog("/tdd", "DEBUG", "line two", undefined, makeDeps());
-
-		const lines = writtenContent.trim().split("\n");
-		expect(lines).toHaveLength(2);
-		expect(lines[0]).toContain("[INFO]");
-		expect(lines[0]).toContain("line one");
-		expect(lines[1]).toContain("[DEBUG]");
-		expect(lines[1]).toContain("line two");
-		expect(mockAppendFileSync).toHaveBeenCalledTimes(2);
-	});
-
-	it("includes data as JSON when provided", () => {
-		tddLog("/tdd", "INFO", "with data", { key: "val", num: 42 }, makeDeps());
-
-		expect(writtenContent).toContain('{"key":"val","num":42}');
-	});
-
-	it("trims to last 1000 lines when exceeded", () => {
-		for (let i = 0; i < 1005; i++) {
-			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
-		}
-
-		const lines = writtenContent.trim().split("\n");
-		expect(lines).toHaveLength(1000);
-		expect(lines[0]).toContain("line 5");
-		expect(lines[999]).toContain("line 1004");
-	});
-
-	it("does not throw on invalid tddDir", () => {
-		// Simulate appendFileSync failure
-		mockAppendFileSync = vi.fn(() => {
-			throw new Error("ENOENT: no such file or directory");
-		});
-
-		expect(() =>
-			tddLog("/nonexistent/path/tdd", "INFO", "fail", undefined, makeDeps()),
-		).not.toThrow();
-	});
-
-	it("handles missing data field gracefully", () => {
-		tddLog("/tdd", "WARN", "no data", undefined, makeDeps());
-
-		expect(writtenContent).toContain("[WARN]");
-		expect(writtenContent).toContain("no data");
-		expect(writtenContent).not.toContain("{}");
-	});
-});

package/adapters/pi/prompts.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Config } from "../../engine/types.js";
-import { getNudgePrompt } from "./prompts.js";
-
-const config: Config = {
-	blockedInRed: ["tests/**/*.test.ts"],
-	blockedInGreen: ["src/**/*.ts"],
-	testCommands: ["npm test"],
-	timeoutSeconds: 30,
-};
-
-describe("getNudgePrompt", () => {
-	it("returns RED prompt with blocked files", () => {
-		const result = getNudgePrompt("red", config);
-		expect(result).toContain("RED");
-		expect(result).toContain("Blocked files: tests/**/*.test.ts");
-	});
-
-	it("returns GREEN prompt with blocked files", () => {
-		const result = getNudgePrompt("green", config);
-		expect(result).toContain("GREEN");
-		expect(result).toContain("Blocked files: src/**/*.ts");
-	});
-
-	it("returns REFACTOR prompt", () => {
-		const result = getNudgePrompt("refactor", config);
-		expect(result).toContain("REFACTOR");
-		expect(result).toContain("free to modify");
-	});
-
-	it("returns empty string for unknown phase", () => {
-		const result = getNudgePrompt("blurple" as any, config);
-		expect(result).toBe("");
-	});
-});