tdd-enforcer 0.2.6 → 0.2.8

package/behaviour.md

@@ -44,10 +44,24 @@ After this gate, every surface has `state` + `config`. Then branches on `state.e
 | `tdd:off` | Setup valid? | If `disabled` → error "already off". Set `enabled: false`. |
 | `tdd:status` | Setup valid? | Show state + config regardless of `enabled`. |
 | `tdd:reset` | Setup valid? | Nuke private git, re-init, snapshot, set `enabled: false`. |
-| `tdd:red` / `tdd:green` / `tdd:refactor` | Setup valid? | If `disabled` → error "not enabled". Set `current` to target phase. |
+| `tdd:red` | Setup valid? | If already in RED → no-op. Snapshot working tree, auto-enable if disabled, set `current: "red"`. Notify "Skipped to RED phase". |
+| `tdd:green` | Setup valid? | If already in GREEN → no-op. Snapshot working tree, auto-enable if disabled, set `current: "green"`. Notify "Skipped to GREEN phase". |
+| `tdd:refactor` | Setup valid? | If already in REFACTOR → no-op. Snapshot working tree, auto-enable if disabled, set `current: "refactor"`. Notify "Skipped to REFACTOR phase". |
 
 All errors reference the tdd-enforcer skill.
 
+### Phase Jump Commands — Usage
+
+These let the user skip phases they don't need for small changes:
+
+| Scenario | Command | Why |
+|----------|---------|-----|
+| "This is just an implementation change, no test needed" | `/tdd:green` | Skip RED, go straight to GREEN. Test files stay locked, implementation files unlocked. |
+| "This is just cleanup, not new behaviour" | `/tdd:refactor` | Skip RED + GREEN. All files unlocked. |
+| "Done refactoring, start next cycle" | `/tdd:red` | Same as `next_tdd_phase` from REFACTOR but direct — no gate check needed. |
+
+Unlike `next_tdd_phase`, these commands do NOT run transition gate checks. The user is explicitly choosing to skip a phase — they own the consequences.
+
 ---
 
 ## Hooks (agent — automatic)

package/biome.json

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.5.0/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"preset": "recommended",
+			"suspicious": {
+				"noExplicitAny": "off"
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/engine/config.test.ts

@@ -1,176 +1,176 @@
-import { describe, it, expect } from "vitest";
-import { existsSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
 import { loadConfig } from "./config.js";
 
 function withTempDir(fn: (dir: string) => void) {
-  const dir = join(tmpdir(), `tdd-test-${Date.now()}`);
-  mkdirSync(dir, { recursive: true });
-  try {
-    fn(dir);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+	const dir = join(tmpdir(), `tdd-test-${Date.now()}`);
+	mkdirSync(dir, { recursive: true });
+	try {
+		fn(dir);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
 }
 
 describe("loadConfig", () => {
-  it("throws when no config exists", () => {
-    withTempDir((dir) => {
-      expect(() => loadConfig(dir)).toThrow();
-    });
-  });
+	it("throws when no config exists", () => {
+		withTempDir((dir) => {
+			expect(() => loadConfig(dir)).toThrow();
+		});
+	});
 
-  it("loads config from rules.json", () => {
-    withTempDir((dir) => {
-      const tddDir = join(dir, ".pi", "tdd");
-      mkdirSync(tddDir, { recursive: true });
-      writeFileSync(
-        join(tddDir, "rules.json"),
-        JSON.stringify({
-          blockedInRed: ["tests/**/*.test.ts"],
-          blockedInGreen: ["src/**/*.ts"],
-          testCommands: ["npm run test"],
-          timeoutSeconds: 60,
-        }),
-        "utf-8",
-      );
+	it("loads config from rules.json", () => {
+		withTempDir((dir) => {
+			const tddDir = join(dir, ".pi", "tdd");
+			mkdirSync(tddDir, { recursive: true });
+			writeFileSync(
+				join(tddDir, "rules.json"),
+				JSON.stringify({
+					blockedInRed: ["tests/**/*.test.ts"],
+					blockedInGreen: ["src/**/*.ts"],
+					testCommands: ["npm run test"],
+					timeoutSeconds: 60,
+				}),
+				"utf-8",
+			);
 
-      const config = loadConfig(dir);
-      expect(config.blockedInRed).toEqual(["tests/**/*.test.ts"]);
-      expect(config.timeoutSeconds).toBe(60);
-    });
-  });
+			const config = loadConfig(dir);
+			expect(config.blockedInRed).toEqual(["tests/**/*.test.ts"]);
+			expect(config.timeoutSeconds).toBe(60);
+		});
+	});
 
-  it("supports multiple test commands", () => {
-    withTempDir((dir) => {
-      const tddDir = join(dir, ".pi", "tdd");
-      mkdirSync(tddDir, { recursive: true });
-      writeFileSync(
-        join(tddDir, "rules.json"),
-        JSON.stringify({
-          blockedInRed: ["tests/**/*.test.ts"],
-          blockedInGreen: ["src/**/*.ts"],
-          testCommands: ["npm run test:unit", "npm run test:integration"],
-        }),
-        "utf-8",
-      );
+	it("supports multiple test commands", () => {
+		withTempDir((dir) => {
+			const tddDir = join(dir, ".pi", "tdd");
+			mkdirSync(tddDir, { recursive: true });
+			writeFileSync(
+				join(tddDir, "rules.json"),
+				JSON.stringify({
+					blockedInRed: ["tests/**/*.test.ts"],
+					blockedInGreen: ["src/**/*.ts"],
+					testCommands: ["npm run test:unit", "npm run test:integration"],
+				}),
+				"utf-8",
+			);
 
-      const config = loadConfig(dir);
-      expect(config.testCommands).toHaveLength(2);
-    });
-  });
+			const config = loadConfig(dir);
+			expect(config.testCommands).toHaveLength(2);
+		});
+	});
 
-  describe("validation — throws on invalid content", () => {
-    it("throws when blockedInRed is not an array", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: "not-an-array",
-            blockedInGreen: ["src/**/*.ts"],
-            testCommands: ["npm test"],
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+	describe("validation — throws on invalid content", () => {
+		it("throws when blockedInRed is not an array", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: "not-an-array",
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws when blockedInGreen is not an array", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: ["tests/**/*.test.ts"],
-            blockedInGreen: null,
-            testCommands: ["npm test"],
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+		it("throws when blockedInGreen is not an array", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: null,
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws when testCommands is not an array", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: ["tests/**/*.test.ts"],
-            blockedInGreen: ["src/**/*.ts"],
-            testCommands: "npm test",
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+		it("throws when testCommands is not an array", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: "npm test",
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws on malformed JSON", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(join(tddDir, "rules.json"), "not json{{", "utf-8");
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+		it("throws on malformed JSON", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(join(tddDir, "rules.json"), "not json{{", "utf-8");
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws when blockedInRed is empty", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: [],
-            blockedInGreen: ["src/**/*.ts"],
-            testCommands: ["npm test"],
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+		it("throws when blockedInRed is empty", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: [],
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws when blockedInGreen is empty", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: ["tests/**/*.test.ts"],
-            blockedInGreen: [],
-            testCommands: ["npm test"],
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
+		it("throws when blockedInGreen is empty", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: [],
+						testCommands: ["npm test"],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
 
-    it("throws when testCommands is empty", () => {
-      withTempDir((dir) => {
-        const tddDir = join(dir, ".pi", "tdd");
-        mkdirSync(tddDir, { recursive: true });
-        writeFileSync(
-          join(tddDir, "rules.json"),
-          JSON.stringify({
-            blockedInRed: ["tests/**/*.test.ts"],
-            blockedInGreen: ["src/**/*.ts"],
-            testCommands: [],
-          }),
-          "utf-8",
-        );
-        expect(() => loadConfig(dir)).toThrow();
-      });
-    });
-  });
+		it("throws when testCommands is empty", () => {
+			withTempDir((dir) => {
+				const tddDir = join(dir, ".pi", "tdd");
+				mkdirSync(tddDir, { recursive: true });
+				writeFileSync(
+					join(tddDir, "rules.json"),
+					JSON.stringify({
+						blockedInRed: ["tests/**/*.test.ts"],
+						blockedInGreen: ["src/**/*.ts"],
+						testCommands: [],
+					}),
+					"utf-8",
+				);
+				expect(() => loadConfig(dir)).toThrow();
+			});
+		});
+	});
 });

package/engine/config.ts

@@ -5,28 +5,31 @@ import type { Config } from "./types.js";
 const TDD_DIR = ".pi/tdd";
 
 export function configPath(projectRoot: string): string {
-  return join(projectRoot, TDD_DIR, "rules.json");
+	return join(projectRoot, TDD_DIR, "rules.json");
 }
 
 export function loadConfig(projectRoot: string): Config {
-  const path = configPath(projectRoot);
-  const raw = readFileSync(path, "utf-8");
-  const parsed = JSON.parse(raw);
+	const path = configPath(projectRoot);
+	const raw = readFileSync(path, "utf-8");
+	const parsed = JSON.parse(raw);
 
-  if (!Array.isArray(parsed.blockedInRed) || parsed.blockedInRed.length === 0) {
-    throw new Error("rules.json: blockedInRed must be a non-empty array");
-  }
-  if (!Array.isArray(parsed.blockedInGreen) || parsed.blockedInGreen.length === 0) {
-    throw new Error("rules.json: blockedInGreen must be a non-empty array");
-  }
-  if (!Array.isArray(parsed.testCommands) || parsed.testCommands.length === 0) {
-    throw new Error("rules.json: testCommands must be a non-empty array");
-  }
+	if (!Array.isArray(parsed.blockedInRed) || parsed.blockedInRed.length === 0) {
+		throw new Error("rules.json: blockedInRed must be a non-empty array");
+	}
+	if (
+		!Array.isArray(parsed.blockedInGreen) ||
+		parsed.blockedInGreen.length === 0
+	) {
+		throw new Error("rules.json: blockedInGreen must be a non-empty array");
+	}
+	if (!Array.isArray(parsed.testCommands) || parsed.testCommands.length === 0) {
+		throw new Error("rules.json: testCommands must be a non-empty array");
+	}
 
-  return {
-    blockedInRed: parsed.blockedInRed,
-    blockedInGreen: parsed.blockedInGreen,
-    testCommands: parsed.testCommands,
-    timeoutSeconds: parsed.timeoutSeconds ?? 120,
-  };
+	return {
+		blockedInRed: parsed.blockedInRed,
+		blockedInGreen: parsed.blockedInGreen,
+		testCommands: parsed.testCommands,
+		timeoutSeconds: parsed.timeoutSeconds ?? 120,
+	};
 }