tdd-enforcer 0.1.0 → 0.1.1

package/adapters/pi/hooks.ts

@@ -1,59 +1,120 @@
+import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { isToolCallEventType, isBashToolResult } from "@earendil-works/pi-coding-agent";
 import { isAllowed } from "../../engine/enforce.js";
 import { changesSinceSnapshot, restoreFiles } from "../../engine/git.js";
 import { loadTddState } from "./helpers.js";
+import { tddLog } from "./log.js";
 
 export function registerHooks(pi: ExtensionAPI): void {
   pi.on("tool_call", async (event, ctx: ExtensionContext) => {
     const root = ctx.cwd;
+    const tddDir = join(root, ".pi", "tdd");
     const tdd = loadTddState(root);
-    if (!tdd.ok) return;
+    if (!tdd.ok) {
+      tddLog(tddDir, "WARN", "tool_call: TDD not active, edit passes through", {
+        toolName: (event as any).toolName,
+        reason: tdd.reason,
+      });
+      return;
+    }
 
     const { state, config } = tdd;
     const phase = state.current;
 
-    // write/edit pre-block
     let filePath: string | undefined;
-    if (isToolCallEventType("write", event)) filePath = event.input.path;
-    else if (isToolCallEventType("edit", event)) filePath = event.input.path;
-    else return;
+    let toolName: string | undefined;
+    if (isToolCallEventType("write", event)) {
+      toolName = "write";
+      filePath = (event as any).input?.path;
+    } else if (isToolCallEventType("edit", event)) {
+      toolName = "edit";
+      filePath = (event as any).input?.path;
+    } else {
+      tddLog(tddDir, "DEBUG", "tool_call: non-file tool, ignored", {
+        toolName: (event as any).toolName,
+      });
+      return;
+    }
+
+    if (!filePath) {
+      tddLog(tddDir, "WARN", "tool_call: no path in input, cannot block", {
+        toolName,
+      });
+      return;
+    }
 
-    if (!filePath) return;
+    const allowed = isAllowed(filePath, phase, config);
+    tddLog(tddDir, "DEBUG", "tool_call: check", { toolName, filePath, phase, allowed });
 
-    if (!isAllowed(filePath, phase, config)) {
+    if (!allowed) {
+      tddLog(tddDir, "INFO", "tool_call: blocked file modification", {
+        toolName,
+        filePath,
+        phase,
+      });
       return {
         block: true,
         reason: `TDD ${phase.toUpperCase()}: "${filePath}" is locked in this phase.`,
       };
     }
+
+    tddLog(tddDir, "DEBUG", "tool_call: allowed", { toolName, filePath, phase });
   });
 
   pi.on("tool_result", async (event, ctx: ExtensionContext) => {
     if (!isBashToolResult(event)) return;
 
     const root = ctx.cwd;
+    const tddDir = join(root, ".pi", "tdd");
     const tdd = loadTddState(root);
-    if (!tdd.ok) return;
+    if (!tdd.ok) {
+      tddLog(tddDir, "WARN", "tool_result: TDD not active, bash passes through", {
+        reason: tdd.reason,
+      });
+      return;
+    }
 
     const { state, config } = tdd;
     const phase = state.current;
-    if (phase === "refactor") return;
+    if (phase === "refactor") {
+      tddLog(tddDir, "DEBUG", "tool_result: refactor phase, no check");
+      return;
+    }
 
     const changed = changesSinceSnapshot(root);
-    if (changed.length === 0) return;
+    if (changed.length === 0) {
+      tddLog(tddDir, "DEBUG", "tool_result: no changes since snapshot");
+      return;
+    }
 
     const violations = changed.filter((f) => !isAllowed(f, phase, config));
-    if (violations.length === 0) return;
+    if (violations.length === 0) {
+      tddLog(tddDir, "DEBUG", "tool_result: no violations among changed files", {
+        changed,
+      });
+      return;
+    }
+
+    tddLog(tddDir, "INFO", "tool_result: reverting violations", {
+      phase,
+      violations,
+      allChanged: changed,
+    });
 
     restoreFiles(root, violations);
 
     const existingText = event.content.map((c) => ("text" in c ? c.text : "")).join("");
     return {
       content: [
-        { type: "text", text: existingText + `\n\n⚠️ TDD: Bash modified files locked in ${phase.toUpperCase()} phase. Reverted: ${violations.join(", ")}` },
+        {
+          type: "text",
+          text:
+            existingText +
+            `\n\n⚠️ TDD: Bash modified files locked in ${phase.toUpperCase()} phase. ` +
+            `Reverted: ${violations.join(", ")}`,
+        },
       ],
     };
   });
-
 }

package/adapters/pi/index.ts

@@ -5,6 +5,7 @@ import { loadPhaseState, loadConfig, savePhaseState, initGit } from "../../engin
 import { registerTools } from "./tools.js";
 import { registerHooks } from "./hooks.js";
 import { loadTddState } from "./helpers.js";
+import { tddLog } from "./log.js";
 
 export default function (pi: ExtensionAPI) {
   pi.registerCommand("tdd:on", {
@@ -13,19 +14,24 @@ export default function (pi: ExtensionAPI) {
       const root = ctx.cwd;
       const tddDir = join(root, ".pi", "tdd");
 
+      tddLog(tddDir, "INFO", "tdd:on: starting");
+
       if (!existsSync(tddDir)) {
+        tddLog(tddDir, "WARN", "tdd:on: missing .pi/tdd/ directory");
         ctx.ui.notify("Missing .pi/tdd/ directory. See the tdd-init skill to learn how to set up TDD configs.", "error");
         return;
       }
 
       const rulesPath = join(tddDir, "rules.json");
       if (!existsSync(rulesPath)) {
+        tddLog(tddDir, "WARN", "tdd:on: missing rules.json");
         ctx.ui.notify("Missing .pi/tdd/rules.json. See the tdd-init skill to learn how to set up TDD configs.", "error");
         return;
       }
 
       const phasePath = join(tddDir, "phase.json");
       if (!existsSync(phasePath)) {
+        tddLog(tddDir, "WARN", "tdd:on: missing phase.json");
         ctx.ui.notify("Missing .pi/tdd/phase.json. See the tdd-init skill to learn how to set up TDD configs.", "error");
         return;
       }
@@ -33,19 +39,28 @@ export default function (pi: ExtensionAPI) {
       let state;
       try {
         state = loadPhaseState(root);
-      } catch {
+      } catch (e) {
+        tddLog(tddDir, "WARN", "tdd:on: invalid phase.json", {
+          error: (e as Error).message,
+        });
         ctx.ui.notify("Invalid .pi/tdd/phase.json. Fix or delete it, then run /tdd:on again.", "error");
         return;
       }
 
       try {
         loadConfig(root);
-      } catch {
+      } catch (e) {
+        tddLog(tddDir, "WARN", "tdd:on: invalid rules.json", {
+          error: (e as Error).message,
+        });
         ctx.ui.notify("Invalid .pi/tdd/rules.json. Fix or delete it, then run /tdd:on again.", "error");
         return;
       }
 
       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;
       }
@@ -53,14 +68,23 @@ export default function (pi: ExtensionAPI) {
       if (!existsSync(join(tddDir, ".git", "HEAD"))) {
         try {
           initGit(root);
-        } catch {
+          tddLog(tddDir, "INFO", "tdd:on: git initialised");
+        } catch (e) {
+          tddLog(tddDir, "ERROR", "tdd:on: git init failed", {
+            error: (e as Error).message,
+          });
           ctx.ui.notify("Failed to initialise private git repo.", "error");
           return;
         }
+      } else {
+        tddLog(tddDir, "DEBUG", "tdd:on: git repo already exists");
       }
 
       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");
     },
   });
@@ -69,22 +93,30 @@ export default function (pi: ExtensionAPI) {
     description: "Disable TDD enforcement",
     handler: async (_args: string, ctx: ExtensionContext) => {
       const root = ctx.cwd;
+      const tddDir = join(root, ".pi", "tdd");
 
       let state;
       try {
         state = loadPhaseState(root);
-      } catch {
+      } catch (e) {
+        tddLog(tddDir, "WARN", "tdd:off: invalid phase.json", {
+          error: (e as Error).message,
+        });
         ctx.ui.notify("Invalid .pi/tdd/phase.json. Fix or delete it, then run /tdd:off again.", "error");
         return;
       }
 
       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");
     },
   });
@@ -93,9 +125,13 @@ export default function (pi: ExtensionAPI) {
     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: TDD not active", {
+          reason: result.reason,
+        });
         ctx.ui.notify(`TDD: ${result.reason}`, "error");
         return;
       }
@@ -106,6 +142,10 @@ export default function (pi: ExtensionAPI) {
       const greenGlobs = config.allowedGreenPhaseFiles.join(", ") || "(none)";
       const commands = config.testCommands.join(", ") || "(none)";
 
+      tddLog(tddDir, "INFO", "tdd:status: queried", {
+        phase: state.current,
+      });
+
       ctx.ui.notify(
         `TDD enforcer enabled\n` +
         `Current phase: ${phaseStr}\n` +

package/adapters/pi/log.ts

@@ -0,0 +1,30 @@
+import { appendFileSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const MAX_LINES = 1000;
+
+export function tddLog(
+  tddDir: string,
+  level: "INFO" | "WARN" | "ERROR" | "DEBUG",
+  msg: string,
+  data?: Record<string, unknown>,
+): void {
+  try {
+    const logPath = join(tddDir, "tdd.log");
+    const timestamp = new Date().toISOString();
+    const dataStr = data !== undefined ? ` ${JSON.stringify(data)}` : "";
+    const line = `[${timestamp}] [${level}] ${msg}${dataStr}\n`;
+
+    appendFileSync(logPath, line, "utf-8");
+
+    // Trim to last MAX_LINES
+    const content = readFileSync(logPath, "utf-8");
+    const lines = content.split("\n");
+    if (lines.length > MAX_LINES + 1) {
+      const trimmed = lines.slice(-MAX_LINES).join("\n") + "\n";
+      writeFileSync(logPath, trimmed, "utf-8");
+    }
+  } catch {
+    // Logging never throws — fail silently
+  }
+}

package/adapters/pi/tools.ts

@@ -27,8 +27,10 @@ export function registerTools(pi: ExtensionAPI): void {
     parameters: Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const root = ctx.cwd;
+      const tddDir = join(root, ".pi", "tdd");
       const tdd = loadTddState(root);
       if (!tdd.ok) {
+        tddLog(tddDir, "WARN", "next_tdd_phase: TDD not active", { reason: tdd.reason });
         return { content: [{ type: "text", text: `TDD: ${tdd.reason}` }], details: {} };
       }
 
@@ -36,12 +38,19 @@ export function registerTools(pi: ExtensionAPI): void {
       const from = state.current;
       const to = nextPhase(from);
       if (!to) {
+        tddLog(tddDir, "WARN", "next_tdd_phase: no next phase", { from });
         return { content: [{ type: "text", text: `No next phase from ${from}.` }], details: {} };
       }
 
+      tddLog(tddDir, "INFO", "next_tdd_phase: starting", { from, to });
+
       // 1. Allowlist check
       const violations = getDisallowedChanges(root, from, config);
       if (violations.length > 0) {
+        tddLog(tddDir, "WARN", "next_tdd_phase: blocked by allowlist", {
+          from,
+          violations,
+        });
         return {
           content: [
             {
@@ -80,16 +89,29 @@ export function registerTools(pi: ExtensionAPI): void {
       };
 
       const gate = await checkGate(from, to, testRunner, config);
+      tddLog(tddDir, "DEBUG", "next_tdd_phase: gate result", {
+        from,
+        to,
+        passed: gate.passed,
+        message: gate.message,
+      });
+
       if (!gate.passed) {
         return { content: [{ type: "text", text: gate.message }], details: {} };
       }
 
       // 3. Snapshot — label with the phase the work was done in
-      snapshot(root, from);
+      const hash = snapshot(root, from);
+      tddLog(tddDir, "INFO", "next_tdd_phase: snapshot created", {
+        from,
+        to,
+        hash,
+      });
 
       // 4. Save state
       state.current = to;
       savePhaseState(root, state);
+      tddLog(tddDir, "INFO", "next_tdd_phase: complete", { from, to });
 
       return {
         content: [{ type: "text", text: getNudgePrompt(to, config) }],
@@ -107,14 +129,21 @@ export function registerTools(pi: ExtensionAPI): void {
     parameters: Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const root = ctx.cwd;
+      const tddDir = join(root, ".pi", "tdd");
       const tdd = loadTddState(root);
       if (!tdd.ok) {
+        tddLog(tddDir, "WARN", "previous_tdd_phase: TDD not active", {
+          reason: tdd.reason,
+        });
         return { content: [{ type: "text", text: `TDD: ${tdd.reason}` }], details: {} };
       }
 
       const { state } = tdd;
 
       if (!hasParent(root)) {
+        tddLog(tddDir, "WARN", "previous_tdd_phase: no parent commit", {
+          phase: state.current,
+        });
         return {
           content: [{ type: "text", text: "No previous phase to revert to." }],
           details: {},
@@ -127,6 +156,9 @@ export function registerTools(pi: ExtensionAPI): void {
       const headMsg = headMessage(root);
       const phaseMatch = headMsg.match(/^tdd: (red|green|refactor)/);
       if (!phaseMatch) {
+        tddLog(tddDir, "ERROR", "previous_tdd_phase: invalid HEAD message", {
+          headMsg,
+        });
         return {
           content: [
             {
@@ -140,16 +172,26 @@ export function registerTools(pi: ExtensionAPI): void {
         };
       }
       const prevPhase = phaseMatch[1] as Phase;
+      tddLog(tddDir, "INFO", "previous_tdd_phase: reverting", {
+        from: state.current,
+        to: prevPhase,
+        headMsg,
+      });
 
       // 1. Nuke any uncommitted changes, WT matches HEAD
       resetHard(root);
+      tddLog(tddDir, "DEBUG", "previous_tdd_phase: resetHard done");
 
       // 2. Pop last snapshot commit, keep its content as unstaged
       undoLastCommit(root);
+      tddLog(tddDir, "DEBUG", "previous_tdd_phase: undoLastCommit done");
 
       // 3. Update phase label from the snapshot's own label
       state.current = prevPhase;
       savePhaseState(root, state);
+      tddLog(tddDir, "INFO", "previous_tdd_phase: complete", {
+        to: prevPhase,
+      });
 
       return {
         content: [
@@ -162,4 +204,56 @@ export function registerTools(pi: ExtensionAPI): void {
       };
     },
   });
+
+  pi.registerTool({
+    name: "tdd_status",
+    label: "TDD Status",
+    description:
+      "Show the current TDD enforcement status: enabled/disabled, current phase, " +
+      "allowed file globs, and test commands.",
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      const root = ctx.cwd;
+      const tddDir = join(root, ".pi", "tdd");
+      const result = loadTddState(root);
+
+      if (!result.ok) {
+        tddLog(tddDir, "WARN", "tdd_status: TDD not active", {
+          reason: result.reason,
+        });
+        return { content: [{ type: "text", text: `TDD: ${result.reason}` }], details: {} };
+      }
+
+      const { state, config } = result;
+      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", {
+        phase: state.current,
+      });
+
+      return {
+        content: [
+          {
+            type: "text",
+            text:
+              `TDD enforcer enabled\n` +
+              `Current phase: ${phaseStr}\n` +
+              `Test files: ${redGlobs}\n` +
+              `Impl files: ${greenGlobs}\n` +
+              `Test commands: ${commands}`,
+          },
+        ],
+        details: {
+          enabled: true,
+          phase: state.current,
+          allowedRedPhaseFiles: config.allowedRedPhaseFiles,
+          allowedGreenPhaseFiles: config.allowedGreenPhaseFiles,
+          testCommands: config.testCommands,
+        },
+      };
+    },
+  });
 }

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "tdd-enforcer",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
-  "keywords": ["pi-package"],
+  "keywords": [
+    "pi-package"
+  ],
   "dependencies": {
     "picomatch": "^4.0.4"
   },
@@ -10,6 +12,8 @@
     "vitest": "^3"
   },
   "pi": {
-    "extensions": ["./adapters/pi/index.ts"]
+    "extensions": [
+      "./adapters/pi/index.ts"
+    ]
   }
 }