tdd-enforcer 0.3.2 → 0.3.4

package/adapters/pi/hooks.ts

@@ -13,9 +13,8 @@ import {
 	gitStashCreate,
 	restoreFilesTo,
 } from "../../engine/git.js";
+import { loadTddState, tddLog } from "../../engine/index.js";
 import type { Config, Phase } from "../../engine/types.js";
-import { loadTddState } from "./helpers.js";
-import { tddLog } from "./log.js";
 
 export async function handleToolCall(
 	event: any,

package/adapters/pi/index.ts

@@ -3,10 +3,14 @@ import type {
 	ExtensionAPI,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { resetGit, savePhaseState, snapshot } from "../../engine/index.js";
-import { loadTddState } from "./helpers.js";
+import {
+	loadTddState,
+	resetGit,
+	savePhaseState,
+	snapshot,
+	tddLog,
+} from "../../engine/index.js";
 import { registerHooks } from "./hooks.js";
-import { tddLog } from "./log.js";
 import { registerTools } from "./tools.js";
 
 export async function handleTddOn(

package/adapters/pi/tools.test.ts

@@ -382,15 +382,20 @@ describe("executeTddStatus", () => {
 		).rejects.toThrow("Missing .pi/tdd/");
 	});
 
-	it("throws when TDD disabled", async () => {
+	it("returns status details when TDD disabled", async () => {
 		mockLoadTddState.mockReturnValue({
 			ok: true,
 			state: { enabled: false, current: "red" },
 			config: CONFIG,
 		});
-		await expect(
-			executeTddStatus({ cwd: "/test" } as any, makeDeps()),
-		).rejects.toThrow("not enabled");
+		const result = await executeTddStatus({ cwd: "/test" } as any, makeDeps());
+		expect(result.content[0].text).toContain("disabled");
+		expect(result.content[0].text).toContain("RED");
+		expect(result.content[0].text).toContain("tests/**/*.test.ts");
+		expect(result.content[0].text).toContain("src/**/*.ts");
+		expect(result.details).toBeDefined();
+		expect(result.details?.enabled).toBe(false);
+		expect(result.details?.phase).toBe("red");
 	});
 
 	it("returns status details when TDD enabled", async () => {

package/adapters/pi/tools.ts

@@ -11,19 +11,22 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import type { Phase, TestRunner } from "../../engine/index.js";
 import {
+	advancePhase,
 	checkGate,
 	getDisallowedChanges,
+	getNudgePrompt,
+	getStatusInfo,
 	hasParent,
 	headMessage,
+	loadTddState,
 	nextPhase,
 	resetHard,
+	revertPhase,
 	savePhaseState,
 	snapshot,
+	tddLog,
 	undoLastCommit,
 } from "../../engine/index.js";
-import { loadTddState } from "./helpers.js";
-import { tddLog } from "./log.js";
-import { getNudgePrompt } from "./prompts.js";
 
 // ── De dependency types ─────────────────────────────────────────────────────
 
@@ -115,26 +118,14 @@ export async function executeNextPhase(
 
 	deps.tddLog(tddDir, "INFO", "next_tdd_phase: starting", { from, to });
 
-	// 1. Allowlist check
-	const violations = deps.getDisallowedChanges(root, from, config);
-	if (violations.length > 0) {
-		deps.tddLog(tddDir, "WARN", "next_tdd_phase: blocked by allowlist", {
-			from,
-			violations,
-		});
-		throw new Error(
-			`BLOCKED: files not allowed in ${from.toUpperCase()} phase:\n` +
-				violations.map((f) => `  - ${f}`).join("\n") +
-				`\nRevert or remove them before proceeding.\n\nInspect with: cd .pi/tdd && git diff HEAD -- ${violations[0]}`,
-		);
-	}
-
-	// 2. Gate check
 	const testRunner: TestRunner = async (commands, timeout) => {
 		const results = await Promise.all(
 			commands.map(async (cmd) => {
 				try {
-					await deps.asyncExec(cmd, { cwd: root, timeout: timeout * 1000 });
+					await deps.asyncExec(cmd, {
+						cwd: root,
+						timeout: timeout * 1000,
+					});
 					return { command: cmd, passed: true };
 				} catch {
 					return { command: cmd, passed: false };
@@ -152,31 +143,30 @@ export async function executeNextPhase(
 		return { passed: true, message: "All tests passed." };
 	};
 
-	const gate = await deps.checkGate(from, to, testRunner, config);
-	deps.tddLog(tddDir, "DEBUG", "next_tdd_phase: gate result", {
-		from,
-		to,
-		passed: gate.passed,
-		message: gate.message,
+	const result = await advancePhase(root, state, config, {
+		nextPhase: deps.nextPhase,
+		getDisallowedChanges: deps.getDisallowedChanges,
+		checkGate: deps.checkGate,
+		snapshot: deps.snapshot,
+		savePhaseState: deps.savePhaseState,
+		testRunner,
 	});
 
-	if (!gate.passed) {
-		throw new Error(gate.message);
+	if (!result.ok) {
+		// advancePhase already returns the exact error message with revert hint
+		// Log the failure at adapter level
+		deps.tddLog(tddDir, "WARN", "next_tdd_phase: blocked by allowlist", {
+			from,
+			violations: result.message,
+		});
+		throw new Error(result.message);
 	}
 
-	// 3. Snapshot — label with the phase the work was done in
-	const hash = deps.snapshot(root, from);
-	deps.tddLog(tddDir, "INFO", "next_tdd_phase: snapshot created", {
+	deps.tddLog(tddDir, "INFO", "next_tdd_phase: complete", {
 		from,
 		to,
-		hash,
 	});
 
-	// 4. Save state
-	state.current = to;
-	deps.savePhaseState(root, state);
-	deps.tddLog(tddDir, "INFO", "next_tdd_phase: complete", { from, to });
-
 	return {
 		content: [{ type: "text", text: `\n${deps.getNudgePrompt(to, config)}` }],
 		details: {},
@@ -208,65 +198,28 @@ export async function executePreviousPhase(
 
 	const { state } = tdd;
 
-	if (!deps.hasParent(root)) {
-		deps.tddLog(tddDir, "WARN", "previous_tdd_phase: no parent commit", {
-			phase: state.current,
-		});
-		throw new Error("No previous phase to revert to.");
-	}
-
-	// Read phase from HEAD snapshot commit message (source of truth).
-	// Snapshot is labeled with the phase the work was done in, so we use
-	// it directly — no hardcoded phase map needed.
-	const headMsg = deps.headMessage(root);
-	const phaseMatch = headMsg.match(/^tdd: (red|green|refactor)/);
-	if (!phaseMatch) {
-		deps.tddLog(tddDir, "ERROR", "previous_tdd_phase: invalid HEAD message", {
-			headMsg,
-		});
-		throw new Error(
-			`HEAD commit "${headMsg}" is not a TDD snapshot. Cannot determine previous phase.\n` +
-				`The private git repo at .pi/tdd must not be manually modified. ` +
-				`Tampering with it will cause TDD state corruption.`,
-		);
-	}
-	const label = phaseMatch[1];
-	if (label !== "red" && label !== "green" && label !== "refactor") {
-		deps.tddLog(tddDir, "ERROR", "previous_tdd_phase: invalid phase label", {
-			headMsg,
-			label,
-		});
-		throw new Error(
-			`HEAD commit "${headMsg}" has unexpected label. Cannot determine previous phase.`,
-		);
-	}
-	const prevPhase: Phase = label;
-	deps.tddLog(tddDir, "INFO", "previous_tdd_phase: reverting", {
-		from: state.current,
-		to: prevPhase,
-		headMsg,
+	const result = await revertPhase(root, state, {
+		hasParent: deps.hasParent,
+		headMessage: deps.headMessage,
+		resetHard: deps.resetHard,
+		undoLastCommit: deps.undoLastCommit,
+		savePhaseState: deps.savePhaseState,
 	});
 
-	// 1. Nuke any uncommitted changes, WT matches HEAD
-	deps.resetHard(root);
-	deps.tddLog(tddDir, "DEBUG", "previous_tdd_phase: resetHard done");
-
-	// 2. Pop last snapshot commit, keep its content as unstaged
-	deps.undoLastCommit(root);
-	deps.tddLog(tddDir, "DEBUG", "previous_tdd_phase: undoLastCommit done");
+	if (!result.ok) {
+		throw new Error(result.message);
+	}
 
-	// 3. Update phase label from the snapshot's own label
-	state.current = prevPhase;
-	deps.savePhaseState(root, state);
 	deps.tddLog(tddDir, "INFO", "previous_tdd_phase: complete", {
-		to: prevPhase,
+		from: state.current,
+		to: result.newState?.current,
 	});
 
 	return {
 		content: [
 			{
 				type: "text",
-				text: `\nReverted to ${prevPhase.toUpperCase()}. Working tree has the previous snapshot content as unstaged changes.`,
+				text: `\n${result.message} Working tree has the previous snapshot content as unstaged changes.`,
 			},
 		],
 		details: {},
@@ -292,35 +245,18 @@ export async function executeTddStatus(
 		});
 		throw new Error(`TDD: ${result.reason}`);
 	}
-	if (!result.state.enabled) {
-		deps.tddLog(tddDir, "WARN", "tdd_status: TDD disabled");
-		throw new Error("TDD is not enabled. Run /tdd:on to enable it.");
-	}
-
 	const { state, config } = result;
-	const phaseStr = state.current.toUpperCase();
-	const redBlk = config.blockedInRed.join(", ") || "(none)";
-	const greenBlk = config.blockedInGreen.join(", ") || "(none)";
-	const commands = config.testCommands.join(", ") || "(none)";
+	const info = getStatusInfo(state, config);
 
 	deps.tddLog(tddDir, "INFO", "tdd_status: queried", {
+		enabled: state.enabled,
 		phase: state.current,
 	});
 
 	return {
-		content: [
-			{
-				type: "text",
-				text:
-					`\nTDD enforcer enabled\n` +
-					`Current phase: ${phaseStr}\n` +
-					`Blocked in RED: ${redBlk}\n` +
-					`Blocked in GREEN: ${greenBlk}\n` +
-					`Test commands: ${commands}`,
-			},
-		],
+		content: [{ type: "text", text: `\n${info}` }],
 		details: {
-			enabled: true,
+			enabled: state.enabled,
 			phase: state.current,
 			blockedInRed: config.blockedInRed,
 			blockedInGreen: config.blockedInGreen,

package/engine/config.test.ts

@@ -61,6 +61,24 @@ describe("loadConfig", () => {
 		});
 	});
 
+	it("defaults timeoutSeconds to 120 when omitted", () => {
+		withTempDir((dir) => {
+			const tddDir = join(dir, ".pi", "tdd");
+			mkdirSync(tddDir, { recursive: true });
+			writeFileSync(
+				join(tddDir, "rules.json"),
+				JSON.stringify({
+					blockedInRed: ["tests/**/*.test.ts"],
+					blockedInGreen: ["src/**/*.ts"],
+					testCommands: ["npm test"],
+				}),
+				"utf-8",
+			);
+			const config = loadConfig(dir);
+			expect(config.timeoutSeconds).toBe(120);
+		});
+	});
+
 	describe("validation — throws on invalid content", () => {
 		it("throws when blockedInRed is not an array", () => {
 			withTempDir((dir) => {
@@ -172,5 +190,56 @@ describe("loadConfig", () => {
 				expect(() => loadConfig(dir)).toThrow();
 			});
 		});
+
+		it("throws when blockedInRed contains non-strings", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: [123],
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
+
+		it("throws when blockedInGreen contains non-strings", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: [null],
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
+
+		it("throws when testCommands contains non-strings", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: ["npm test", 456],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 	});
 });

package/engine/config.ts

@@ -16,15 +16,24 @@ export function loadConfig(projectRoot: string): Config {
 	if (!Array.isArray(parsed.blockedInRed) || parsed.blockedInRed.length === 0) {
 		throw new Error("rules.json: blockedInRed must be a non-empty array");
 	}
+	if (!parsed.blockedInRed.every((p: unknown) => typeof p === "string")) {
+		throw new Error("rules.json: blockedInRed must contain only strings");
+	}
 	if (
 		!Array.isArray(parsed.blockedInGreen) ||
 		parsed.blockedInGreen.length === 0
 	) {
 		throw new Error("rules.json: blockedInGreen must be a non-empty array");
 	}
+	if (!parsed.blockedInGreen.every((p: unknown) => typeof p === "string")) {
+		throw new Error("rules.json: blockedInGreen must contain only strings");
+	}
 	if (!Array.isArray(parsed.testCommands) || parsed.testCommands.length === 0) {
 		throw new Error("rules.json: testCommands must be a non-empty array");
 	}
+	if (!parsed.testCommands.every((p: unknown) => typeof p === "string")) {
+		throw new Error("rules.json: testCommands must contain only strings");
+	}
 
 	return {
 		blockedInRed: parsed.blockedInRed,

package/engine/index.ts

@@ -17,7 +17,12 @@ export {
 	undoLastCommit,
 	untrackedFiles,
 } from "./git.js";
-export { loadPhaseState, savePhaseState } from "./state.js";
+export { tddLog } from "./log.js";
+export type { AdvanceResult } from "./orchestrate.js";
+export { advancePhase, getStatusInfo, revertPhase } from "./orchestrate.js";
+export { getNudgePrompt } from "./prompts.js";
+export type { TddLoadResult } from "./state.js";
+export { loadPhaseState, loadTddState, savePhaseState } from "./state.js";
 export { checkGate, getDisallowedChanges, nextPhase } from "./transition.js";
 export type {
 	Config,

package/engine/log.test.ts

@@ -0,0 +1,171 @@
+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("appends log line with timestamp and level", () => {
+		tddLog("/tdd", "INFO", "hello", undefined, makeDeps());
+
+		expect(mockAppendFileSync).toHaveBeenCalledOnce();
+		const written = mockAppendFileSync.mock.calls[0][1] as string;
+		expect(written).toMatch(/^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+		expect(written).toContain("[INFO]");
+		expect(written).toContain("hello");
+		expect(written.endsWith("\n")).toBe(true);
+	});
+
+	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("includes data after message separated by a space", () => {
+		tddLog("/tdd", "INFO", "msg", { a: 1 }, makeDeps());
+
+		const line = writtenContent.trim();
+		expect(line).toContain('msg {"a":1}');
+	});
+
+	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 when appendFileSync fails", () => {
+		mockAppendFileSync = vi.fn(() => {
+			throw new Error("ENOENT: no such file or directory");
+		});
+
+		expect(() =>
+			tddLog("/nonexistent/path/tdd", "INFO", "fail", undefined, makeDeps()),
+		).not.toThrow();
+	});
+
+	it("does not throw when readFileSync fails (first write)", () => {
+		mockReadFileSync = vi.fn(() => {
+			throw new Error("ENOENT: no such file or directory");
+		});
+
+		expect(() =>
+			tddLog("/tdd", "INFO", "hello", undefined, makeDeps()),
+		).not.toThrow();
+		expect(mockAppendFileSync).toHaveBeenCalled();
+	});
+
+	it("handles undefined data gracefully", () => {
+		tddLog("/tdd", "WARN", "no data", undefined, makeDeps());
+
+		expect(writtenContent).toContain("[WARN]");
+		expect(writtenContent).toContain("no data");
+		expect(writtenContent).not.toContain("{}");
+	});
+
+	it("logs at WARN level", () => {
+		tddLog("/tdd", "WARN", "warning message", undefined, makeDeps());
+		expect(writtenContent).toContain("[WARN]");
+	});
+
+	it("logs at ERROR level", () => {
+		tddLog("/tdd", "ERROR", "error message", undefined, makeDeps());
+		expect(writtenContent).toContain("[ERROR]");
+	});
+
+	it("logs at DEBUG level", () => {
+		tddLog("/tdd", "DEBUG", "debug message", undefined, makeDeps());
+		expect(writtenContent).toContain("[DEBUG]");
+	});
+
+	it("writes to the path join(tddDir, 'tdd.log')", () => {
+		tddLog("/custom/tdd/path", "INFO", "test", undefined, makeDeps());
+
+		expect(mockAppendFileSync).toHaveBeenCalledWith(
+			"/custom/tdd/path/tdd.log",
+			expect.any(String),
+			"utf-8",
+		);
+	});
+
+	it("trims to exactly 1000 lines keeping newest", () => {
+		for (let i = 0; i < 1001; i++) {
+			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
+		}
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(1000);
+		expect(lines[0]).toContain("line 1");
+		expect(lines[999]).toContain("line 1000");
+	});
+
+	it("keeps all lines when exactly at MAX_LINES", () => {
+		for (let i = 0; i < 1000; i++) {
+			tddLog("/tdd", "DEBUG", `line ${i}`, undefined, makeDeps());
+		}
+
+		const lines = writtenContent.trim().split("\n");
+		expect(lines).toHaveLength(1000);
+		expect(lines[0]).toContain("line 0");
+		expect(lines[999]).toContain("line 999");
+	});
+
+	it("appends to existing content instead of overwriting", () => {
+		tddLog("/tdd", "INFO", "first", undefined, makeDeps());
+		tddLog("/tdd", "INFO", "second", undefined, makeDeps());
+
+		expect(writtenContent).toContain("first");
+		expect(writtenContent).toContain("second");
+	});
+
+	it("uses the real filesystem deps by default", () => {
+		// Just verify the function exists and can be called without deps
+		expect(typeof tddLog).toBe("function");
+	});
+});