tdd-enforcer 0.2.5 → 0.2.7

package/adapters/pi/index.ts

@@ -1,222 +1,244 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
-import { savePhaseState, resetGit, snapshot } from "../../engine/index.js";
-import { registerTools } from "./tools.js";
-import { registerHooks } from "./hooks.js";
+import type {
+	ExtensionAPI,
+	ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { resetGit, savePhaseState, snapshot } from "../../engine/index.js";
 import { loadTddState } from "./helpers.js";
+import { registerHooks } from "./hooks.js";
 import { tddLog } from "./log.js";
+import { registerTools } from "./tools.js";
 
 export async function handleTddOn(
-  ctx: ExtensionContext,
-  deps: {
-    loadTddState: typeof loadTddState;
-    snapshot: typeof snapshot;
-    savePhaseState: typeof savePhaseState;
-    tddLog: typeof tddLog;
-  } = {
-    loadTddState,
-    snapshot,
-    savePhaseState,
-    tddLog,
-  },
+	ctx: ExtensionContext,
+	deps: {
+		loadTddState: typeof loadTddState;
+		snapshot: typeof snapshot;
+		savePhaseState: typeof savePhaseState;
+		tddLog: typeof tddLog;
+	} = {
+		loadTddState,
+		snapshot,
+		savePhaseState,
+		tddLog,
+	},
 ): Promise<void> {
-  const root = ctx.cwd;
-  const tddDir = join(root, ".pi", "tdd");
-
-  deps.tddLog(tddDir, "INFO", "tdd:on: starting");
-
-  const setup = deps.loadTddState(root);
-  if (!setup.ok) {
-    deps.tddLog(tddDir, "WARN", "tdd:on: setup invalid", { reason: setup.reason });
-    ctx.ui.notify(setup.reason, "error");
-    return;
-  }
-
-  const { state } = setup;
-
-  if (state.enabled) {
-    deps.tddLog(tddDir, "INFO", "tdd:on: already enabled", {
-      phase: state.current,
-    });
-    ctx.ui.notify(`TDD already enabled — ${state.current.toUpperCase()} phase`, "info");
-    return;
-  }
-
-  // Snapshot working tree so stale baseline doesn't nuke user changes
-  deps.snapshot(root, state.current);
-  deps.tddLog(tddDir, "INFO", "tdd:on: snapshot taken", {
-    phase: state.current,
-  });
-
-  state.enabled = true;
-  deps.savePhaseState(root, state);
-  deps.tddLog(tddDir, "INFO", "tdd:on: enabled", {
-    phase: state.current,
-  });
-  ctx.ui.notify(`TDD enabled — ${state.current.toUpperCase()} phase`, "info");
+	const root = ctx.cwd;
+	const tddDir = join(root, ".pi", "tdd");
+
+	deps.tddLog(tddDir, "INFO", "tdd:on: starting");
+
+	const setup = deps.loadTddState(root);
+	if (!setup.ok) {
+		deps.tddLog(tddDir, "WARN", "tdd:on: setup invalid", {
+			reason: setup.reason,
+		});
+		ctx.ui.notify(setup.reason, "error");
+		return;
+	}
+
+	const { state } = setup;
+
+	if (state.enabled) {
+		deps.tddLog(tddDir, "INFO", "tdd:on: already enabled", {
+			phase: state.current,
+		});
+		ctx.ui.notify(
+			`TDD already enabled — ${state.current.toUpperCase()} phase`,
+			"info",
+		);
+		return;
+	}
+
+	// Snapshot working tree so stale baseline doesn't nuke user changes
+	deps.snapshot(root, state.current);
+	deps.tddLog(tddDir, "INFO", "tdd:on: snapshot taken", {
+		phase: state.current,
+	});
+
+	state.enabled = true;
+	deps.savePhaseState(root, state);
+	deps.tddLog(tddDir, "INFO", "tdd:on: enabled", {
+		phase: state.current,
+	});
+	ctx.ui.notify(`TDD enabled — ${state.current.toUpperCase()} phase`, "info");
 }
 
 export async function handleTddOff(
-  ctx: ExtensionContext,
-  deps: {
-    loadTddState: typeof loadTddState;
-    savePhaseState: typeof savePhaseState;
-    tddLog: typeof tddLog;
-  } = {
-    loadTddState,
-    savePhaseState,
-    tddLog,
-  },
+	ctx: ExtensionContext,
+	deps: {
+		loadTddState: typeof loadTddState;
+		savePhaseState: typeof savePhaseState;
+		tddLog: typeof tddLog;
+	} = {
+		loadTddState,
+		savePhaseState,
+		tddLog,
+	},
 ): Promise<void> {
-  const root = ctx.cwd;
-  const tddDir = join(root, ".pi", "tdd");
-
-  const setup = deps.loadTddState(root);
-  if (!setup.ok) {
-    deps.tddLog(tddDir, "WARN", "tdd:off: setup invalid", { reason: setup.reason });
-    ctx.ui.notify(setup.reason, "error");
-    return;
-  }
-
-  const { state } = setup;
-
-  if (!state.enabled) {
-    deps.tddLog(tddDir, "INFO", "tdd:off: already disabled");
-    ctx.ui.notify("TDD already disabled", "info");
-    return;
-  }
-
-  state.enabled = false;
-  deps.savePhaseState(root, state);
-  deps.tddLog(tddDir, "INFO", "tdd:off: disabled", {
-    was: state.current,
-  });
-  ctx.ui.notify("TDD disabled", "info");
+	const root = ctx.cwd;
+	const tddDir = join(root, ".pi", "tdd");
+
+	const setup = deps.loadTddState(root);
+	if (!setup.ok) {
+		deps.tddLog(tddDir, "WARN", "tdd:off: setup invalid", {
+			reason: setup.reason,
+		});
+		ctx.ui.notify(setup.reason, "error");
+		return;
+	}
+
+	const { state } = setup;
+
+	if (!state.enabled) {
+		deps.tddLog(tddDir, "INFO", "tdd:off: already disabled");
+		ctx.ui.notify("TDD already disabled", "info");
+		return;
+	}
+
+	state.enabled = false;
+	deps.savePhaseState(root, state);
+	deps.tddLog(tddDir, "INFO", "tdd:off: disabled", {
+		was: state.current,
+	});
+	ctx.ui.notify("TDD disabled", "info");
 }
 
 export async function handleTddStatus(
-  ctx: ExtensionContext,
-  deps: {
-    loadTddState: typeof loadTddState;
-    tddLog: typeof tddLog;
-  } = {
-    loadTddState,
-    tddLog,
-  },
+	ctx: ExtensionContext,
+	deps: {
+		loadTddState: typeof loadTddState;
+		tddLog: typeof tddLog;
+	} = {
+		loadTddState,
+		tddLog,
+	},
 ): Promise<void> {
-  const root = ctx.cwd;
-  const tddDir = join(root, ".pi", "tdd");
-  const result = deps.loadTddState(root);
-
-  if (!result.ok) {
-    deps.tddLog(tddDir, "WARN", "tdd:status: setup invalid", {
-      reason: result.reason,
-    });
-    ctx.ui.notify(`TDD: ${result.reason}`, "error");
-    return;
-  }
-
-  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)";
-
-  deps.tddLog(tddDir, "INFO", "tdd:status: queried", {
-    enabled: state.enabled,
-    phase: state.current,
-  });
-
-  ctx.ui.notify(
-    `TDD enforcer ${enabledStr}\n` +
-    `Current phase: ${phaseStr}\n` +
-    `Blocked in RED: ${redBlk}\n` +
-    `Blocked in GREEN: ${greenBlk}\n` +
-    `Test commands: ${commands}`,
-    "info",
-  );
+	const root = ctx.cwd;
+	const tddDir = join(root, ".pi", "tdd");
+	const result = deps.loadTddState(root);
+
+	if (!result.ok) {
+		deps.tddLog(tddDir, "WARN", "tdd:status: setup invalid", {
+			reason: result.reason,
+		});
+		ctx.ui.notify(`TDD: ${result.reason}`, "error");
+		return;
+	}
+
+	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)";
+
+	deps.tddLog(tddDir, "INFO", "tdd:status: queried", {
+		enabled: state.enabled,
+		phase: state.current,
+	});
+
+	ctx.ui.notify(
+		`TDD enforcer ${enabledStr}\n` +
+			`Current phase: ${phaseStr}\n` +
+			`Blocked in RED: ${redBlk}\n` +
+			`Blocked in GREEN: ${greenBlk}\n` +
+			`Test commands: ${commands}`,
+		"info",
+	);
 }
 
 export async function handleTddReset(
-  ctx: ExtensionContext,
-  deps: {
-    loadTddState: typeof loadTddState;
-    resetGit: typeof resetGit;
-    snapshot: typeof snapshot;
-    savePhaseState: typeof savePhaseState;
-    tddLog: typeof tddLog;
-  } = {
-    loadTddState,
-    resetGit,
-    snapshot,
-    savePhaseState,
-    tddLog,
-  },
+	ctx: ExtensionContext,
+	deps: {
+		loadTddState: typeof loadTddState;
+		resetGit: typeof resetGit;
+		snapshot: typeof snapshot;
+		savePhaseState: typeof savePhaseState;
+		tddLog: typeof tddLog;
+	} = {
+		loadTddState,
+		resetGit,
+		snapshot,
+		savePhaseState,
+		tddLog,
+	},
 ): Promise<void> {
-  const root = ctx.cwd;
-  const tddDir = join(root, ".pi", "tdd");
-
-  deps.tddLog(tddDir, "INFO", "tdd:reset: starting");
-
-  const setup = deps.loadTddState(root);
-  if (!setup.ok) {
-    deps.tddLog(tddDir, "WARN", "tdd:reset: setup invalid", { reason: setup.reason });
-    ctx.ui.notify(setup.reason, "error");
-    return;
-  }
-
-  // Nuke git history and re-init
-  try {
-    deps.resetGit(root);
-    deps.tddLog(tddDir, "INFO", "tdd:reset: git reset and re-initialised");
-  } catch (e) {
-    deps.tddLog(tddDir, "ERROR", "tdd:reset: git reset failed", {
-      error: (e as Error).message,
-    });
-    ctx.ui.notify("Failed to reset private git repo.", "error");
-    return;
-  }
-
-  // Snapshot current working tree
-  deps.snapshot(root, "red");
-  deps.tddLog(tddDir, "INFO", "tdd:reset: snapshot taken");
-
-  // Reset state to RED (disabled, user must run /tdd:on)
-  deps.savePhaseState(root, { enabled: false, current: "red" });
-  deps.tddLog(tddDir, "INFO", "tdd:reset: complete");
-
-  ctx.ui.notify(
-    "TDD snapshot history reset. Run /tdd:on to re-enable enforcement.",
-    "warning",
-  );
+	const root = ctx.cwd;
+	const tddDir = join(root, ".pi", "tdd");
+
+	deps.tddLog(tddDir, "INFO", "tdd:reset: starting");
+
+	const setup = deps.loadTddState(root);
+	if (!setup.ok) {
+		deps.tddLog(tddDir, "WARN", "tdd:reset: setup invalid", {
+			reason: setup.reason,
+		});
+		ctx.ui.notify(setup.reason, "error");
+		return;
+	}
+
+	// Nuke git history and re-init
+	try {
+		deps.resetGit(root);
+		deps.tddLog(tddDir, "INFO", "tdd:reset: git reset and re-initialised");
+	} catch (e) {
+		deps.tddLog(tddDir, "ERROR", "tdd:reset: git reset failed", {
+			error: (e as Error).message,
+		});
+		ctx.ui.notify("Failed to reset private git repo.", "error");
+		return;
+	}
+
+	// Snapshot current working tree
+	deps.snapshot(root, "red");
+	deps.tddLog(tddDir, "INFO", "tdd:reset: snapshot taken");
+
+	// Reset state to RED (disabled, user must run /tdd:on)
+	deps.savePhaseState(root, { enabled: false, current: "red" });
+	deps.tddLog(tddDir, "INFO", "tdd:reset: complete");
+
+	ctx.ui.notify(
+		"TDD snapshot history reset. Run /tdd:on to re-enable enforcement.",
+		"warning",
+	);
 }
 
 export default function (pi: ExtensionAPI) {
-  const defaultDeps = { loadTddState, snapshot, savePhaseState, tddLog, resetGit };
-
-  pi.registerCommand("tdd:on", {
-    description: "Enable TDD enforcement",
-    handler: (_args: string, ctx: ExtensionContext) => handleTddOn(ctx, defaultDeps),
-  });
-
-  pi.registerCommand("tdd:off", {
-    description: "Disable TDD enforcement",
-    handler: (_args: string, ctx: ExtensionContext) => handleTddOff(ctx, defaultDeps),
-  });
-
-  pi.registerCommand("tdd:status", {
-    description: "Show TDD enforcement status",
-    handler: (_args: string, ctx: ExtensionContext) => handleTddStatus(ctx, defaultDeps),
-  });
-
-  pi.registerCommand("tdd:reset", {
-    description:
-      "WARNING: Destroys ALL TDD snapshot history and resets to RED phase. " +
-      "Working tree is preserved. Run /tdd:on to re-enable after reset.",
-    handler: (_args: string, ctx: ExtensionContext) => handleTddReset(ctx, { ...defaultDeps, resetGit }),
-  });
-
-  registerTools(pi);
-  registerHooks(pi);
+	const defaultDeps = {
+		loadTddState,
+		snapshot,
+		savePhaseState,
+		tddLog,
+		resetGit,
+	};
+
+	pi.registerCommand("tdd:on", {
+		description: "Enable TDD enforcement",
+		handler: (_args: string, ctx: ExtensionContext) =>
+			handleTddOn(ctx, defaultDeps),
+	});
+
+	pi.registerCommand("tdd:off", {
+		description: "Disable TDD enforcement",
+		handler: (_args: string, ctx: ExtensionContext) =>
+			handleTddOff(ctx, defaultDeps),
+	});
+
+	pi.registerCommand("tdd:status", {
+		description: "Show TDD enforcement status",
+		handler: (_args: string, ctx: ExtensionContext) =>
+			handleTddStatus(ctx, defaultDeps),
+	});
+
+	pi.registerCommand("tdd:reset", {
+		description:
+			"WARNING: Destroys ALL TDD snapshot history and resets to RED phase. " +
+			"Working tree is preserved. Run /tdd:on to re-enable after reset.",
+		handler: (_args: string, ctx: ExtensionContext) =>
+			handleTddReset(ctx, { ...defaultDeps, resetGit }),
+	});
+
+	registerTools(pi);
+	registerHooks(pi);
 }

package/adapters/pi/log.test.ts

@@ -1,95 +1,95 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
+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("{}");
-  });
+	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("{}");
+	});
 });