tdd-enforcer 0.1.6 → 0.1.7

package/adapters/pi/hooks.ts

@@ -2,10 +2,13 @@ import { join, relative } 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 } from "../../engine/git.js";
+import { changesSince, restoreFilesTo, gitStashCreate } from "../../engine/git.js";
 import { loadTddState } from "./helpers.js";
 import { tddLog } from "./log.js";
 
+// Correlates tool_call → tool_result for per-command bash diff
+const preBashStashes = new Map<string, string>();
+
 export function registerHooks(pi: ExtensionAPI): void {
   pi.on("tool_call", async (event, ctx: ExtensionContext) => {
     const root = ctx.cwd;
@@ -22,6 +25,24 @@ export function registerHooks(pi: ExtensionAPI): void {
     const { state, config } = tdd;
     const phase = state.current;
 
+    // Bash: stash pre-command state for per-command diff later
+    if ((event as any).toolName === "bash") {
+      try {
+        const hash = gitStashCreate(root);
+        preBashStashes.set(event.toolCallId, hash);
+        tddLog(tddDir, "DEBUG", "tool_call: bash pre-stash created", {
+          toolCallId: event.toolCallId,
+          hash,
+        });
+      } catch (e) {
+        tddLog(tddDir, "ERROR", "tool_call: bash pre-stash failed", {
+          toolCallId: event.toolCallId,
+          error: (e as Error).message,
+        });
+      }
+      return;
+    }
+
     let filePath: string | undefined;
     let toolName: string | undefined;
     if (isToolCallEventType("write", event)) {
@@ -69,6 +90,17 @@ export function registerHooks(pi: ExtensionAPI): void {
 
     const root = ctx.cwd;
     const tddDir = join(root, ".pi", "tdd");
+
+    // Get the pre-bash stash for this tool call
+    const stashHash = preBashStashes.get(event.toolCallId);
+    preBashStashes.delete(event.toolCallId);
+    if (!stashHash) {
+      tddLog(tddDir, "WARN", "tool_result: no pre-bash stash found", {
+        toolCallId: event.toolCallId,
+      });
+      return;
+    }
+
     const tdd = loadTddState(root);
     if (!tdd.ok) {
       tddLog(tddDir, "WARN", "tool_result: TDD not active, bash passes through", {
@@ -84,14 +116,16 @@ export function registerHooks(pi: ExtensionAPI): void {
       return;
     }
 
-    const changed = changesSinceSnapshot(root);
+    // Diff against pre-bash stash — only changes from THIS command
+    const changed = changesSince(root, stashHash);
+
     if (changed.length === 0) {
-      tddLog(tddDir, "DEBUG", "tool_result: no changes since snapshot");
+      tddLog(tddDir, "DEBUG", "tool_result: no changes in this bash command");
       return;
     }
 
-    const violations = changed.filter((f) => !isAllowed(f, phase, config));
-    if (violations.length === 0) {
+    const cmdViolations = changed.filter((f) => !isAllowed(f, phase, config));
+    if (cmdViolations.length === 0) {
       tddLog(tddDir, "DEBUG", "tool_result: no violations among changed files", {
         changed,
       });
@@ -100,20 +134,29 @@ export function registerHooks(pi: ExtensionAPI): void {
 
     tddLog(tddDir, "WARN", "tool_result: locked files modified by bash", {
       phase,
-      violations,
+      violations: cmdViolations,
     });
 
+    // Revert only this command's violations back to pre-bash state
+    restoreFilesTo(root, cmdViolations, stashHash);
+
+    // Find remaining allowed changes from this command
+    const cmdAllowed = changed.filter((f) => isAllowed(f, phase, config));
+
     const existingText = event.content.map((c) => ("text" in c ? c.text : "")).join("");
+    let warning = `\n\n⛔ ${phase.toUpperCase()}: reverted locked files modified by bash:`;
+    cmdViolations.forEach((f) => (warning += `\n  - ${f}`));
+    if (cmdAllowed.length > 0) {
+      warning += `\n\nAllowed changes retained:`;
+      cmdAllowed.forEach((f) => (warning += `\n  - ${f}`));
+    }
+
     return {
       isError: true,
       content: [
         {
           type: "text",
-          text:
-            existingText +
-            `\n\n⛔ ${phase.toUpperCase()}: bash modified locked files: ${violations.join(", ")}\n` +
-            `next_tdd_phase blocked until reverted. ` +
-            `Inspect with: cd .pi/tdd && git diff HEAD -- ${violations[0]}`,
+          text: existingText + warning,
         },
       ],
     };

package/engine/git.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeAll, afterAll } from "vitest";
 import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { initGit, snapshot, changesSinceSnapshot, modifiedFiles, untrackedFiles, restoreFiles, headHash, headMessage, hasParent, resetHard, undoLastCommit } from "./git.js";
+import { initGit, snapshot, changesSinceSnapshot, modifiedFiles, untrackedFiles, restoreFilesTo, headHash, headMessage, hasParent, resetHard, undoLastCommit } from "./git.js";
 
 let testDir: string;
 
@@ -56,11 +56,11 @@ describe("git operations", () => {
     expect(changes).toContain("another.ts");
   });
 
-  it("restoreFiles reverts specific files", () => {
+  it("restoreFilesTo reverts specific files", () => {
     writeFileSync(join(testDir, "src", "main.ts"), "// to be reverted", "utf-8");
     expect(modifiedFiles(testDir)).toContain("src/main.ts");
 
-    restoreFiles(testDir, ["src/main.ts"]);
+    restoreFilesTo(testDir, ["src/main.ts"]);
     expect(modifiedFiles(testDir)).not.toContain("src/main.ts");
   });
 
@@ -94,9 +94,9 @@ describe("git operations", () => {
     }
   });
 
-  it("restoreFiles does nothing when files list is empty", () => {
+  it("restoreFilesTo does nothing when files list is empty", () => {
     // Should not throw
-    expect(() => restoreFiles(testDir, [])).not.toThrow();
+    expect(() => restoreFilesTo(testDir, [])).not.toThrow();
   });
 });
 

package/engine/git.ts

@@ -61,7 +61,7 @@ export function changesSinceSnapshot(projectRoot: string): string[] {
   return [...new Set([...modifiedFiles(projectRoot), ...untrackedFiles(projectRoot)])];
 }
 
-export function restoreFiles(projectRoot: string, files: string[]): void {
+export function restoreFilesTo(projectRoot: string, files: string[], source?: string): void {
   if (files.length === 0) return;
 
   // Separate tracked (git restore) from untracked (delete)
@@ -76,7 +76,8 @@ export function restoreFiles(projectRoot: string, files: string[]): void {
 
   if (trackedFiles.length > 0) {
     const escaped = trackedFiles.map((f) => `"${f}"`).join(" ");
-    gitExec(`restore -- ${escaped}`, projectRoot, { stdio: "pipe" as const });
+    const sourceFlag = source ? `--source=${source} ` : "";
+    gitExec(`restore ${sourceFlag}--worktree -- ${escaped}`, projectRoot, { stdio: "pipe" as const });
   }
 
   for (const f of untrackedFiles) {
@@ -88,6 +89,16 @@ export function restoreFiles(projectRoot: string, files: string[]): void {
   }
 }
 
+/**
+ * Create a lightweight commit of the current working tree without touching the stash ref.
+ * Returns the commit hash. Used as a pre-bash baseline for per-command diff.
+ */
+export function gitStashCreate(projectRoot: string): string {
+  const hash = gitExec("stash create --include-untracked", projectRoot).trim();
+  if (!hash) throw new Error("git stash create returned empty hash");
+  return hash;
+}
+
 export function headHash(projectRoot: string): string {
   return gitExec("rev-parse HEAD", projectRoot).trim();
 }
@@ -107,6 +118,17 @@ export function hasParent(projectRoot: string): boolean {
   }
 }
 
+/**
+ * Get files changed since a specific commit (instead of HEAD).
+ */
+export function changesSince(projectRoot: string, commitHash: string): string[] {
+  const out = gitExec(`diff --name-only ${commitHash} -- .`, projectRoot).trim();
+  const files = out ? out.split("\n") : [];
+  // Also include untracked files
+  const untracked = untrackedFiles(projectRoot);
+  return [...new Set([...files, ...untracked])];
+}
+
 /** Hard reset — discard all uncommitted changes (tracked and untracked), keep HEAD. */
 export function resetHard(projectRoot: string): void {
   gitExec("reset --hard", projectRoot, { stdio: "pipe" as const });

package/engine/index.ts

@@ -1,5 +1,5 @@
 export { isAllowed, disallowedFiles } from "./enforce.js";
-export { initGit, snapshot, changesSinceSnapshot, modifiedFiles, untrackedFiles, restoreFiles, headHash, headMessage, hasParent, resetHard, undoLastCommit } from "./git.js";
+export { initGit, snapshot, changesSinceSnapshot, changesSince, modifiedFiles, untrackedFiles, restoreFilesTo, gitStashCreate, headHash, headMessage, hasParent, resetHard, undoLastCommit } from "./git.js";
 export { loadConfig } from "./config.js";
 export { loadPhaseState, savePhaseState } from "./state.js";
 export { nextPhase, checkGate, getDisallowedChanges } from "./transition.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdd-enforcer",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "keywords": [
     "pi-package"