tdd-enforcer 0.2.2 → 0.2.3

package/adapters/pi/index.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { handleTddOn, handleTddOff, handleTddStatus, handleTddReset } from "./index.js";
+
+const config = {
+  allowedRedPhaseFiles: ["tests/**/*.test.ts"],
+  allowedGreenPhaseFiles: ["src/**/*.ts"],
+  testCommands: ["npm test"],
+  timeoutSeconds: 30,
+};
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeCtx(dir = "/test") {
+  const notifications: Array<{ message: string; type: string }> = [];
+  return {
+    cwd: dir,
+    ui: { notify: (message: string, type: string) => notifications.push({ message, type }) },
+    notifications, // stored alongside for easy assertion
+  } as any;
+}
+
+function captureNotifications(ctx: any): Array<{ message: string; type: string }> {
+  return ctx.notifications;
+}
+
+// ── handleTddOn ─────────────────────────────────────────────────────────────
+
+describe("handleTddOn", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockSnapshot: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides = {}) {
+    return {
+      loadTddState: mockLoadTddState,
+      snapshot: mockSnapshot,
+      savePhaseState: mockSavePhaseState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    mockLoadTddState = vi.fn();
+    mockSnapshot = vi.fn().mockReturnValue("hash123");
+    mockSavePhaseState = vi.fn();
+    mockTddLog = vi.fn();
+  });
+
+  it("enables TDD, takes snapshot, notifies user", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddOn(ctx, makeDeps());
+
+    expect(mockSnapshot).toHaveBeenCalledWith("/test", "red");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", {
+      enabled: true,
+      current: "red",
+    });
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("TDD enabled");
+    expect(ctx.notifications[0].type).toBe("info");
+  });
+
+  it("shows already enabled when TDD already on", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddOn(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("already enabled");
+    expect(ctx.notifications[0].type).toBe("info");
+    expect(mockSnapshot).not.toHaveBeenCalled();
+  });
+
+  it("shows error when setup invalid", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/",
+    });
+
+    const ctx = makeCtx();
+    await handleTddOn(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("Missing .pi/tdd/");
+    expect(ctx.notifications[0].type).toBe("error");
+  });
+});
+
+// ── handleTddOff ────────────────────────────────────────────────────────────
+
+describe("handleTddOff", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides = {}) {
+    return {
+      loadTddState: mockLoadTddState,
+      savePhaseState: mockSavePhaseState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    mockLoadTddState = vi.fn();
+    mockSavePhaseState = vi.fn();
+    mockTddLog = vi.fn();
+  });
+
+  it("disables TDD, notifies user", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "red" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddOff(ctx, makeDeps());
+
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", {
+      enabled: false,
+      current: "red",
+    });
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("disabled");
+    expect(ctx.notifications[0].type).toBe("info");
+  });
+
+  it("shows already disabled when TDD already off", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddOff(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("already disabled");
+    expect(ctx.notifications[0].type).toBe("info");
+    expect(mockSavePhaseState).not.toHaveBeenCalled();
+  });
+
+  it("shows error when setup invalid", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/",
+    });
+
+    const ctx = makeCtx();
+    await handleTddOff(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("Missing .pi/tdd/");
+    expect(ctx.notifications[0].type).toBe("error");
+  });
+});
+
+// ── handleTddStatus ─────────────────────────────────────────────────────────
+
+describe("handleTddStatus", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides = {}) {
+    return {
+      loadTddState: mockLoadTddState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    mockLoadTddState = vi.fn();
+    mockTddLog = vi.fn();
+  });
+
+  it("shows status when TDD enabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddStatus(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("enabled");
+    expect(ctx.notifications[0].message).toContain("GREEN");
+    expect(ctx.notifications[0].type).toBe("info");
+  });
+
+  it("shows status when TDD disabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: false, current: "red" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddStatus(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("disabled");
+    expect(ctx.notifications[0].message).toContain("RED");
+    expect(ctx.notifications[0].type).toBe("info");
+  });
+
+  it("shows error when setup invalid", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/",
+    });
+
+    const ctx = makeCtx();
+    await handleTddStatus(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("Missing .pi/tdd/");
+    expect(ctx.notifications[0].type).toBe("error");
+  });
+});
+
+// ── handleTddReset ──────────────────────────────────────────────────────────
+
+describe("handleTddReset", () => {
+  let mockLoadTddState: ReturnType<typeof vi.fn>;
+  let mockResetGit: ReturnType<typeof vi.fn>;
+  let mockSnapshot: ReturnType<typeof vi.fn>;
+  let mockSavePhaseState: ReturnType<typeof vi.fn>;
+  let mockTddLog: ReturnType<typeof vi.fn>;
+
+  function makeDeps(overrides = {}) {
+    return {
+      loadTddState: mockLoadTddState,
+      resetGit: mockResetGit,
+      snapshot: mockSnapshot,
+      savePhaseState: mockSavePhaseState,
+      tddLog: mockTddLog,
+      ...overrides,
+    };
+  }
+
+  beforeEach(() => {
+    mockLoadTddState = vi.fn();
+    mockResetGit = vi.fn();
+    mockSnapshot = vi.fn().mockReturnValue("hash123");
+    mockSavePhaseState = vi.fn();
+    mockTddLog = vi.fn();
+  });
+
+  it("nukes git, re-inits, snapshots, resets state to RED disabled", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: true,
+      state: { enabled: true, current: "green" },
+      config,
+    });
+
+    const ctx = makeCtx();
+    await handleTddReset(ctx, makeDeps());
+
+    expect(mockResetGit).toHaveBeenCalledWith("/test");
+    expect(mockSnapshot).toHaveBeenCalledWith("/test", "red");
+    expect(mockSavePhaseState).toHaveBeenCalledWith("/test", {
+      enabled: false,
+      current: "red",
+    });
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("reset");
+    expect(ctx.notifications[0].type).toBe("warning");
+  });
+
+  it("shows error when setup invalid", async () => {
+    mockLoadTddState.mockReturnValue({
+      ok: false,
+      reason: "Missing .pi/tdd/",
+    });
+
+    const ctx = makeCtx();
+    await handleTddReset(ctx, makeDeps());
+
+    expect(ctx.notifications).toHaveLength(1);
+    expect(ctx.notifications[0].message).toContain("Missing .pi/tdd/");
+    expect(ctx.notifications[0].type).toBe("error");
+  });
+});

package/adapters/pi/index.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { savePhaseState, resetGit, snapshot } from "../../engine/index.js";
 import { registerTools } from "./tools.js";
@@ -7,157 +6,215 @@ import { registerHooks } from "./hooks.js";
 import { loadTddState } from "./helpers.js";
 import { tddLog } from "./log.js";
 
+export async function handleTddOn(
+  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");
+}
+
+export async function handleTddOff(
+  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");
+}
+
+export async function handleTddStatus(
+  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 redGlobs = config.allowedRedPhaseFiles.join(", ") || "(none)";
+  const greenGlobs = config.allowedGreenPhaseFiles.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` +
+    `Test files: ${redGlobs}\n` +
+    `Impl files: ${greenGlobs}\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,
+  },
+): 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",
+  );
+}
+
 export default function (pi: ExtensionAPI) {
+  const defaultDeps = { loadTddState, snapshot, savePhaseState, tddLog, resetGit };
+
   pi.registerCommand("tdd:on", {
     description: "Enable TDD enforcement",
-    handler: async (_args: string, ctx: ExtensionContext) => {
-      const root = ctx.cwd;
-      const tddDir = join(root, ".pi", "tdd");
-
-      tddLog(tddDir, "INFO", "tdd:on: starting");
-
-      const setup = loadTddState(root);
-      if (!setup.ok) {
-        tddLog(tddDir, "WARN", "tdd:on: setup invalid", { reason: setup.reason });
-        ctx.ui.notify(setup.reason, "error");
-        return;
-      }
-
-      const { state } = setup;
-
-      if (state.enabled) {
-        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
-      snapshot(root, state.current);
-      tddLog(tddDir, "INFO", "tdd:on: snapshot taken", {
-        phase: state.current,
-      });
-
-      state.enabled = true;
-      savePhaseState(root, state);
-      tddLog(tddDir, "INFO", "tdd:on: enabled", {
-        phase: state.current,
-      });
-      ctx.ui.notify(`TDD enabled — ${state.current.toUpperCase()} phase`, "info");
-    },
+    handler: (_args: string, ctx: ExtensionContext) => handleTddOn(ctx, defaultDeps),
   });
 
   pi.registerCommand("tdd:off", {
     description: "Disable TDD enforcement",
-    handler: async (_args: string, ctx: ExtensionContext) => {
-      const root = ctx.cwd;
-      const tddDir = join(root, ".pi", "tdd");
-
-      const setup = loadTddState(root);
-      if (!setup.ok) {
-        tddLog(tddDir, "WARN", "tdd:off: setup invalid", { reason: setup.reason });
-        ctx.ui.notify(setup.reason, "error");
-        return;
-      }
-
-      const { state } = setup;
-
-      if (!state.enabled) {
-        tddLog(tddDir, "INFO", "tdd:off: already disabled");
-        ctx.ui.notify("TDD already disabled", "info");
-        return;
-      }
-
-      state.enabled = false;
-      savePhaseState(root, state);
-      tddLog(tddDir, "INFO", "tdd:off: disabled", {
-        was: state.current,
-      });
-      ctx.ui.notify("TDD disabled", "info");
-    },
+    handler: (_args: string, ctx: ExtensionContext) => handleTddOff(ctx, defaultDeps),
   });
 
   pi.registerCommand("tdd:status", {
     description: "Show TDD enforcement status",
-    handler: async (_args: string, ctx: ExtensionContext) => {
-      const root = ctx.cwd;
-      const tddDir = join(root, ".pi", "tdd");
-      const result = loadTddState(root);
-
-      if (!result.ok) {
-        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 redGlobs = config.allowedRedPhaseFiles.join(", ") || "(none)";
-      const greenGlobs = config.allowedGreenPhaseFiles.join(", ") || "(none)";
-      const commands = config.testCommands.join(", ") || "(none)";
-
-      tddLog(tddDir, "INFO", "tdd:status: queried", {
-        enabled: state.enabled,
-        phase: state.current,
-      });
-
-      ctx.ui.notify(
-        `TDD enforcer ${enabledStr}\n` +
-        `Current phase: ${phaseStr}\n` +
-        `Test files: ${redGlobs}\n` +
-        `Impl files: ${greenGlobs}\n` +
-        `Test commands: ${commands}`,
-        "info"
-      );
-    },
+    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: async (_args: string, ctx: ExtensionContext) => {
-      const root = ctx.cwd;
-      const tddDir = join(root, ".pi", "tdd");
-
-      tddLog(tddDir, "INFO", "tdd:reset: starting");
-
-      const setup = loadTddState(root);
-      if (!setup.ok) {
-        tddLog(tddDir, "WARN", "tdd:reset: setup invalid", { reason: setup.reason });
-        ctx.ui.notify(setup.reason, "error");
-        return;
-      }
-
-      // Nuke git history and re-init
-      try {
-        resetGit(root);
-        tddLog(tddDir, "INFO", "tdd:reset: git reset and re-initialised");
-      } catch (e) {
-        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
-      snapshot(root, "red");
-      tddLog(tddDir, "INFO", "tdd:reset: snapshot taken");
-
-      // Reset state to RED (disabled, user must run /tdd:on)
-      savePhaseState(root, { enabled: false, current: "red" });
-      tddLog(tddDir, "INFO", "tdd:reset: complete");
-
-      ctx.ui.notify(
-        "TDD snapshot history reset. Run /tdd:on to re-enable enforcement.",
-        "warning",
-      );
-    },
+    handler: (_args: string, ctx: ExtensionContext) => handleTddReset(ctx, { ...defaultDeps, resetGit }),
   });
 
   registerTools(pi);