tdd-enforcer 0.3.3 → 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.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: {},
@@ -293,11 +246,7 @@ export async function executeTddStatus(
 		throw new Error(`TDD: ${result.reason}`);
 	}
 	const { state, config } = result;
-	const enabledStr = state.enabled ? "enabled" : "disabled";
-	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,
@@ -305,17 +254,7 @@ export async function executeTddStatus(
 	});
 
 	return {
-		content: [
-			{
-				type: "text",
-				text:
-					`\nTDD enforcer ${enabledStr}\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: state.enabled,
 			phase: state.current,

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");
+	});
+});