tdd-enforcer 0.3.6 → 0.3.7

package/README.md

@@ -3,11 +3,16 @@
 **Lock files per TDD phase. Gate transitions on test outcomes.**
 
 [![CI](https://github.com/Cyclone1070/tdd-enforcer/actions/workflows/ci.yml/badge.svg)](https://github.com/Cyclone1070/tdd-enforcer/actions/workflows/ci.yml)
+
 [![npm version](https://img.shields.io/npm/v/tdd-enforcer.svg)](https://www.npmjs.com/package/tdd-enforcer)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 ---
 
+<img width="741" height="586" alt="Screenshot 2026-06-26 at 20 52 02" src="https://github.com/user-attachments/assets/4bba490d-ab94-43b1-8c2a-552b34374aee" />
+
+---
+
 ## Features
 
 - **Phase-locked file access** — prevents the agent from modifying test files in GREEN and implementation files in RED. Everything is open in REFACTOR

package/adapters/pi/index.test.ts

@@ -416,5 +416,3 @@ describe("handleTddJump", () => {
 		expect(ctx.notifications[0].message).toContain("Skipped to RED phase");
 	});
 });
-
-

package/adapters/pi/index.ts

@@ -152,7 +152,6 @@ export async function handleTddStatus(
 	);
 }
 
-
 export async function handleTddJump(
 	phase: "red" | "green" | "refactor",
 	ctx: ExtensionContext,

package/adapters/pi/tools.test.ts

@@ -246,6 +246,85 @@ describe("executeNextPhase", () => {
 			current: "red",
 		});
 	});
+
+	it("passes ctx.signal through to asyncExec for user cancellation", async () => {
+		const ac = new AbortController();
+
+		// Use green→refactor so passing tests satisfy the gate check
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: true, current: "green" },
+			config: CONFIG,
+		});
+
+		// A checkGate mock that actually runs the testRunner so asyncExec is called
+		const callTestRunner = vi.fn(
+			async (_from: string, _to: string, tr: any, cfg: any) => {
+				return tr(cfg.testCommands, cfg.timeoutSeconds);
+			},
+		);
+
+		mockAsyncExec.mockImplementation(async (_cmd: string, opts?: any) => {
+			expect(opts?.signal).toBe(ac.signal);
+			return { stdout: "", stderr: "" };
+		});
+
+		await executeNextPhase(
+			{ cwd: "/test", signal: ac.signal } as any,
+			makeDeps({ checkGate: callTestRunner as any }),
+		);
+
+		expect(mockAsyncExec).toHaveBeenCalledWith(
+			"npm test",
+			expect.objectContaining({ signal: ac.signal }),
+		);
+	});
+
+	it("returns cancellation message when signal is aborted mid-execution", async () => {
+		const ac = new AbortController();
+
+		mockLoadTddState.mockReturnValue({
+			ok: true,
+			state: { enabled: true, current: "green" },
+			config: CONFIG,
+		});
+
+		const callTestRunner = vi.fn(
+			async (_from: string, _to: string, tr: any, cfg: any) => {
+				return tr(cfg.testCommands, cfg.timeoutSeconds);
+			},
+		);
+
+		// asyncExec that hangs until signal aborts, then rejects like exec does on kill
+		mockAsyncExec.mockImplementation(async (_cmd: string, opts?: any) => {
+			return new Promise((_resolve, reject) => {
+				if (opts?.signal) {
+					if (opts.signal.aborted) {
+						const err: any = new Error("canceled");
+						err.killed = true;
+						reject(err);
+					} else {
+						opts.signal.addEventListener("abort", () => {
+							const err: any = new Error("canceled");
+							err.killed = true;
+							reject(err);
+						});
+					}
+				}
+			});
+		});
+
+		const promise = executeNextPhase(
+			{ cwd: "/test", signal: ac.signal } as any,
+			makeDeps({ checkGate: callTestRunner as any }),
+		);
+
+		ac.abort();
+
+		await expect(promise).rejects.toThrow("cancelled");
+		expect(mockSnapshot).not.toHaveBeenCalled();
+		expect(mockSavePhaseState).not.toHaveBeenCalled();
+	});
 });
 
 // ── executePreviousPhase ────────────────────────────────────────────────────

package/adapters/pi/tools.ts

@@ -40,7 +40,7 @@ export interface NextPhaseDeps {
 	getNudgePrompt: typeof getNudgePrompt;
 	asyncExec: (
 		command: string,
-		options?: { cwd?: string; timeout?: number },
+		options?: { cwd?: string; timeout?: number; signal?: AbortSignal },
 	) => Promise<{ stdout: string; stderr: string }>;
 	tddLog: typeof tddLog;
 }
@@ -118,6 +118,7 @@ export async function executeNextPhase(
 
 	deps.tddLog(tddDir, "INFO", "next_tdd_phase: starting", { from, to });
 
+	const signal = ctx.signal;
 	const testRunner: TestRunner = async (commands, timeout) => {
 		const results = await Promise.all(
 			commands.map(async (cmd) => {
@@ -125,21 +126,36 @@ export async function executeNextPhase(
 					await deps.asyncExec(cmd, {
 						cwd: root,
 						timeout: timeout * 1000,
+						signal,
 					});
 					return { command: cmd, passed: true, timedOut: false } as const;
 				} catch (err) {
-					const timedOut = (err as any)?.killed === true;
+					const killed = (err as any)?.killed === true;
+					const cancelled = signal?.aborted === true;
+					const timedOut = killed && !cancelled;
 					return {
 						command: cmd,
 						passed: false,
 						timedOut,
+						cancelled,
 					} as const;
 				}
 			}),
 		);
 
+		const cancelled = results.filter((r) => (r as any).cancelled === true);
 		const timedOut = results.filter((r) => r.timedOut);
-		const failed = results.filter((r) => !r.passed && !r.timedOut);
+		const failed = results.filter(
+			(r) => !r.passed && !r.timedOut && !(r as any).cancelled,
+		);
+
+		if (cancelled.length > 0) {
+			return {
+				passed: false,
+				cancelled: true,
+				message: `Test execution was cancelled.\n${cancelled.map((f) => `  - ${f.command}`).join("\n")}`,
+			};
+		}
 
 		if (timedOut.length > 0) {
 			return {

package/engine/transition.test.ts

@@ -25,15 +25,22 @@ describe("nextPhase", () => {
 
 // ── Pure unit tests: checkGate ──────────────────────────────────────────────
 
-function makeRunner(passed: boolean, timeout?: boolean): TestRunner {
+function makeRunner(
+	passed: boolean,
+	timeout?: boolean,
+	cancelled?: boolean,
+): TestRunner {
 	return async (_cmds, _timeout) => ({
 		passed,
 		timeout,
-		message: timeout
-			? "npm test: timed out"
-			: passed
-				? "all ok"
-				: "tests failed",
+		cancelled,
+		message: cancelled
+			? "Test execution was cancelled."
+			: timeout
+				? "npm test: timed out"
+				: passed
+					? "all ok"
+					: "tests failed",
 	});
 }
 
@@ -70,6 +77,19 @@ describe("checkGate", () => {
 			expect(r.message).toMatch(/timed out/i);
 			expect(r.message).not.toMatch(/proceed|fail/i);
 		});
+
+		it("blocks on cancellation — preserves cancellation message", async () => {
+			const r = await checkGate(
+				"red",
+				"green",
+				makeRunner(false, undefined, true),
+				testConfig,
+			);
+			expect(r.passed).toBe(false);
+			expect(r.cancelled).toBe(true);
+			expect(r.message).toMatch(/cancelled/i);
+			expect(r.message).not.toMatch(/timed out|proceed|fail/i);
+		});
 	});
 
 	describe("green → refactor (tests must pass)", () => {
@@ -107,6 +127,19 @@ describe("checkGate", () => {
 			expect(r.message).toMatch(/timed out/i);
 			expect(r.message).not.toMatch(/fix them/i);
 		});
+
+		it("blocks on cancellation — preserves cancellation message", async () => {
+			const r = await checkGate(
+				"green",
+				"refactor",
+				makeRunner(false, undefined, true),
+				testConfig,
+			);
+			expect(r.passed).toBe(false);
+			expect(r.cancelled).toBe(true);
+			expect(r.message).toMatch(/cancelled/i);
+			expect(r.message).not.toMatch(/timed out|fix them/i);
+		});
 	});
 
 	describe("refactor → red (tests must pass)", () => {
@@ -144,6 +177,19 @@ describe("checkGate", () => {
 			expect(r.message).toMatch(/timed out/i);
 			expect(r.message).not.toMatch(/fix them/i);
 		});
+
+		it("blocks on cancellation — preserves cancellation message", async () => {
+			const r = await checkGate(
+				"refactor",
+				"red",
+				makeRunner(false, undefined, true),
+				testConfig,
+			);
+			expect(r.passed).toBe(false);
+			expect(r.cancelled).toBe(true);
+			expect(r.message).toMatch(/cancelled/i);
+			expect(r.message).not.toMatch(/timed out|fix them/i);
+		});
 	});
 
 	it("passes test commands to the runner", async () => {

package/engine/transition.ts

@@ -14,6 +14,7 @@ export interface GateResult {
 	passed: boolean;
 	message: string;
 	timeout?: boolean;
+	cancelled?: boolean;
 }
 
 export type TestRunner = (
@@ -35,6 +36,15 @@ export async function checkGate(
 ): Promise<GateResult> {
 	const result = await testRunner(config.testCommands, config.timeoutSeconds);
 
+	// Cancellation blocks all transitions — preserve the message from testRunner
+	if (result.cancelled) {
+		return {
+			passed: false,
+			cancelled: true,
+			message: result.message,
+		};
+	}
+
 	// Timeout blocks all transitions — don't suggest "fix tests"
 	if (result.timeout) {
 		return {

package/package.json

@@ -1,43 +1,43 @@
 {
-    "name": "tdd-enforcer",
-    "version": "0.3.6",
-    "type": "module",
-    "description": "TDD enforcer extension for the pi coding agent — enforces Red-Green-Refactor phases with file access restrictions and transition gates",
-    "license": "MIT",
-    "author": "Cyclone1070 <hoangmai1070@gmail.com>",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/Cyclone1070/tdd-enforcer.git"
-    },
-    "bugs": {
-        "url": "https://github.com/Cyclone1070/tdd-enforcer/issues"
-    },
-    "homepage": "https://github.com/Cyclone1070/tdd-enforcer#readme",
-    "scripts": {
-        "check": "biome check --write . && vitest run",
-        "lint": "biome check .",
-        "lint:fix": "biome check --write .",
-        "test": "vitest run"
-    },
-    "keywords": [
-        "pi-package"
-    ],
-    "dependencies": {
-        "picomatch": "^4.0.4"
-    },
-    "devDependencies": {
-        "@biomejs/biome": "^2.5.0",
-        "@earendil-works/pi-coding-agent": "^0.79.6",
-        "@types/node": "^25.9.3",
-        "typebox": "^1.2.16",
-        "vitest": "^3"
-    },
-    "pi": {
-        "extensions": [
-            "./adapters/pi/index.ts"
-        ],
-        "skills": [
-            "./skills"
-        ]
-    }
+	"name": "tdd-enforcer",
+	"version": "0.3.7",
+	"type": "module",
+	"description": "TDD enforcer extension for the pi coding agent — enforces Red-Green-Refactor phases with file access restrictions and transition gates",
+	"license": "MIT",
+	"author": "Cyclone1070 <hoangmai1070@gmail.com>",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Cyclone1070/tdd-enforcer.git"
+	},
+	"bugs": {
+		"url": "https://github.com/Cyclone1070/tdd-enforcer/issues"
+	},
+	"homepage": "https://github.com/Cyclone1070/tdd-enforcer#readme",
+	"scripts": {
+		"check": "biome check --write . && vitest run",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"test": "vitest run"
+	},
+	"keywords": [
+		"pi-package"
+	],
+	"dependencies": {
+		"picomatch": "^4.0.4"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.5.0",
+		"@earendil-works/pi-coding-agent": "^0.79.6",
+		"@types/node": "^25.9.3",
+		"typebox": "^1.2.16",
+		"vitest": "^3"
+	},
+	"pi": {
+		"extensions": [
+			"./adapters/pi/index.ts"
+		],
+		"skills": [
+			"./skills"
+		]
+	}
 }