tdd-enforcer 0.2.2 → 0.2.5

package/engine/config.test.ts

@@ -28,8 +28,8 @@ describe("loadConfig", () => {
       writeFileSync(
         join(tddDir, "rules.json"),
         JSON.stringify({
-          allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-          allowedGreenPhaseFiles: ["src/**/*.ts"],
+          blockedInRed: ["tests/**/*.test.ts"],
+          blockedInGreen: ["src/**/*.ts"],
           testCommands: ["npm run test"],
           timeoutSeconds: 60,
         }),
@@ -37,7 +37,7 @@ describe("loadConfig", () => {
       );
 
       const config = loadConfig(dir);
-      expect(config.allowedRedPhaseFiles).toEqual(["tests/**/*.test.ts"]);
+      expect(config.blockedInRed).toEqual(["tests/**/*.test.ts"]);
       expect(config.timeoutSeconds).toBe(60);
     });
   });
@@ -49,8 +49,8 @@ describe("loadConfig", () => {
       writeFileSync(
         join(tddDir, "rules.json"),
         JSON.stringify({
-          allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-          allowedGreenPhaseFiles: ["src/**/*.ts"],
+          blockedInRed: ["tests/**/*.test.ts"],
+          blockedInGreen: ["src/**/*.ts"],
           testCommands: ["npm run test:unit", "npm run test:integration"],
         }),
         "utf-8",
@@ -62,15 +62,15 @@ describe("loadConfig", () => {
   });
 
   describe("validation — throws on invalid content", () => {
-    it("throws when allowedRedPhaseFiles is not an array", () => {
+    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({
-            allowedRedPhaseFiles: "not-an-array",
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: "not-an-array",
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -79,15 +79,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedGreenPhaseFiles is not an array", () => {
+    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({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: null,
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: null,
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -103,8 +103,8 @@ describe("loadConfig", () => {
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: "npm test",
           }),
           "utf-8",
@@ -122,15 +122,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedRedPhaseFiles is empty", () => {
+    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({
-            allowedRedPhaseFiles: [],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: [],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -139,15 +139,15 @@ describe("loadConfig", () => {
       });
     });
 
-    it("throws when allowedGreenPhaseFiles is empty", () => {
+    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({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: [],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: [],
             testCommands: ["npm test"],
           }),
           "utf-8",
@@ -163,8 +163,8 @@ describe("loadConfig", () => {
         writeFileSync(
           join(tddDir, "rules.json"),
           JSON.stringify({
-            allowedRedPhaseFiles: ["tests/**/*.test.ts"],
-            allowedGreenPhaseFiles: ["src/**/*.ts"],
+            blockedInRed: ["tests/**/*.test.ts"],
+            blockedInGreen: ["src/**/*.ts"],
             testCommands: [],
           }),
           "utf-8",

package/engine/config.ts

@@ -13,19 +13,19 @@ export function loadConfig(projectRoot: string): Config {
   const raw = readFileSync(path, "utf-8");
   const parsed = JSON.parse(raw);
 
-  if (!Array.isArray(parsed.allowedRedPhaseFiles) || parsed.allowedRedPhaseFiles.length === 0) {
-    throw new Error("rules.json: allowedRedPhaseFiles 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.allowedGreenPhaseFiles) || parsed.allowedGreenPhaseFiles.length === 0) {
-    throw new Error("rules.json: allowedGreenPhaseFiles 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 {
-    allowedRedPhaseFiles: parsed.allowedRedPhaseFiles,
-    allowedGreenPhaseFiles: parsed.allowedGreenPhaseFiles,
+    blockedInRed: parsed.blockedInRed,
+    blockedInGreen: parsed.blockedInGreen,
     testCommands: parsed.testCommands,
     timeoutSeconds: parsed.timeoutSeconds ?? 120,
   };

package/engine/enforce.test.ts

@@ -3,8 +3,8 @@ import { isAllowed, disallowedFiles } from "./enforce.js";
 import type { Config } from "./types.js";
 
 const testConfig: Config = {
-  allowedRedPhaseFiles: ["tests/**/*.test.ts", "specs/**/*.spec.ts"],
-  allowedGreenPhaseFiles: ["src/**/*.ts", "lib/**/*.ts"],
+  blockedInRed: ["src/**/*.ts", "lib/**/*.ts"],
+  blockedInGreen: ["tests/**/*.test.ts", "specs/**/*.spec.ts"],
   testCommands: ["npm test"],
   timeoutSeconds: 30,
 };
@@ -16,41 +16,114 @@ describe("isAllowed", () => {
   });
 
   describe("red phase", () => {
-    it("allows red phase files", () => {
-      expect(isAllowed("tests/unit/foo.test.ts", "red", testConfig)).toBe(true);
-      expect(isAllowed("specs/api.spec.ts", "red", testConfig)).toBe(true);
+    it("allows free files", () => {
+      expect(isAllowed("README.md", "red", testConfig)).toBe(true);
+      expect(isAllowed("package.json", "red", testConfig)).toBe(true);
     });
 
-    it("blocks green phase files", () => {
+    it("blocks files in blockedInRed", () => {
       expect(isAllowed("src/main.ts", "red", testConfig)).toBe(false);
       expect(isAllowed("lib/helper.ts", "red", testConfig)).toBe(false);
     });
 
-    it("allows free files (match neither)", () => {
-      expect(isAllowed("README.md", "red", testConfig)).toBe(true);
-      expect(isAllowed("package.json", "red", testConfig)).toBe(true);
+    it("allows test files in red phase", () => {
+      expect(isAllowed("tests/foo.test.ts", "red", testConfig)).toBe(true);
+      expect(isAllowed("specs/api.spec.ts", "red", testConfig)).toBe(true);
     });
   });
 
   describe("green phase", () => {
-    it("allows green phase files", () => {
+    it("allows free files", () => {
+      expect(isAllowed("README.md", "green", testConfig)).toBe(true);
+    });
+
+    it("allows implementation files in green phase", () => {
       expect(isAllowed("src/main.ts", "green", testConfig)).toBe(true);
       expect(isAllowed("lib/helper.ts", "green", testConfig)).toBe(true);
     });
 
-    it("blocks red phase files", () => {
-      expect(isAllowed("tests/unit/foo.test.ts", "green", testConfig)).toBe(false);
+    it("blocks files in blockedInGreen", () => {
+      expect(isAllowed("tests/foo.test.ts", "green", testConfig)).toBe(false);
       expect(isAllowed("specs/api.spec.ts", "green", testConfig)).toBe(false);
     });
+  });
 
-    it("allows free files", () => {
-      expect(isAllowed("README.md", "green", testConfig)).toBe(true);
+  describe("negation patterns (!)", () => {
+    const exclConfig: Config = {
+      blockedInRed: ["src/**/*.ts"],
+      blockedInGreen: ["src/**/*.ts", "!**/*.test.ts"],
+      testCommands: ["npm test"],
+      timeoutSeconds: 30,
+    };
+
+    it("excludes files matching !pattern from the block", () => {
+      expect(isAllowed("src/main.test.ts", "green", exclConfig)).toBe(true);
     });
-  });
 
-  it("handles nested glob patterns", () => {
-    expect(isAllowed("src/deep/nested/file.ts", "green", testConfig)).toBe(true);
-    expect(isAllowed("tests/deep/nested/test.test.ts", "red", testConfig)).toBe(true);
+    it("still blocks files not matching the exclusion", () => {
+      expect(isAllowed("src/main.ts", "green", exclConfig)).toBe(false);
+    });
+
+    it("excludes spec files with a second !pattern", () => {
+      const multiExcl: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["src/**/*.ts", "!**/*.test.ts", "!**/*.spec.ts"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("src/main.spec.ts", "green", multiExcl)).toBe(true);
+      expect(isAllowed("src/main.test.ts", "green", multiExcl)).toBe(true);
+      expect(isAllowed("src/main.ts", "green", multiExcl)).toBe(false);
+    });
+
+    it("excludes via complex glob in negation pattern", () => {
+      const complexExcl: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["src/**", "!src/vendor/**"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("src/vendor/lib.js", "green", complexExcl)).toBe(true);
+      expect(isAllowed("src/app.ts", "green", complexExcl)).toBe(false);
+      expect(isAllowed("src/utils/helper.ts", "green", complexExcl)).toBe(false);
+    });
+
+    it("supports ! negation in blockedInRed as well", () => {
+      const redExcl: Config = {
+        blockedInRed: ["src/**/*.ts", "!src/**/*.test.ts"],
+        blockedInGreen: [],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      // test file excluded from block → allowed in red
+      expect(isAllowed("src/main.test.ts", "red", redExcl)).toBe(true);
+      // impl file still blocked
+      expect(isAllowed("src/main.ts", "red", redExcl)).toBe(false);
+      // free file unaffected
+      expect(isAllowed("README.md", "red", redExcl)).toBe(true);
+    });
+
+    it("free file with exclusions in config remains free", () => {
+      expect(isAllowed("README.md", "green", exclConfig)).toBe(true);
+    });
+
+    it("file matching !pattern alone (no positive match) is not blocked", () => {
+      // File matches the negation pattern but NOT the positive pattern.
+      // MatchPatterns returns false (no positive match), so it's not blocked.
+      expect(isAllowed("other/foo.test.ts", "green", exclConfig)).toBe(true);
+    });
+
+    it("exclusion-only patterns block nothing", () => {
+      const exclOnly: Config = {
+        blockedInRed: [],
+        blockedInGreen: ["!**/*.test.ts"],
+        testCommands: [],
+        timeoutSeconds: 30,
+      };
+      expect(isAllowed("any/file.ts", "green", exclOnly)).toBe(true);
+      expect(isAllowed("README.md", "green", exclOnly)).toBe(true);
+      expect(isAllowed("tests/foo.test.ts", "green", exclOnly)).toBe(true);
+    });
   });
 });
 
@@ -64,12 +137,12 @@ describe("disallowedFiles", () => {
     expect(disallowedFiles([], "green", testConfig)).toEqual([]);
   });
 
-  it("filters out green files in red phase", () => {
+  it("filters out blockedInRed files in red phase", () => {
     const files = ["src/main.ts", "README.md", "tests/foo.test.ts"];
     expect(disallowedFiles(files, "red", testConfig)).toEqual(["src/main.ts"]);
   });
 
-  it("filters out red files in green phase", () => {
+  it("filters out blockedInGreen files in green phase", () => {
     const files = ["tests/foo.test.ts", "README.md", "src/main.ts"];
     expect(disallowedFiles(files, "green", testConfig)).toEqual(["tests/foo.test.ts"]);
   });
@@ -79,11 +152,4 @@ describe("disallowedFiles", () => {
     expect(disallowedFiles(free, "red", testConfig)).toEqual([]);
     expect(disallowedFiles(free, "green", testConfig)).toEqual([]);
   });
-
-  it("blocks everything when all files match the other phase", () => {
-    const redFiles = ["tests/a.test.ts", "specs/b.spec.ts"];
-    const greenFiles = ["src/c.ts", "lib/d.ts"];
-    expect(disallowedFiles(redFiles, "green", testConfig)).toEqual(redFiles);
-    expect(disallowedFiles(greenFiles, "red", testConfig)).toEqual(greenFiles);
-  });
 });

package/engine/enforce.ts

@@ -1,25 +1,49 @@
 import picomatch from "picomatch";
 import type { Phase, Config } from "./types.js";
 
+/**
+ * Match a file path against a list of glob patterns with !exclusion support.
+ *
+ * Positive patterns (no ! prefix) include a file in the match.
+ * Negative patterns (! prefix) exclude a file from the match.
+ * A file matches if it matches any positive pattern AND no negative pattern.
+ * Empty pattern list = no match.
+ */
+function matchPatterns(patterns: string[], filePath: string): boolean {
+  const positive: string[] = [];
+  const negative: string[] = [];
+
+  for (const p of patterns) {
+    if (p.startsWith("!")) {
+      negative.push(p.slice(1));
+    } else {
+      positive.push(p);
+    }
+  }
+
+  if (positive.length === 0) return false;
+
+  const matchesPositive = positive.some((p) => picomatch(p)(filePath));
+  if (!matchesPositive) return false;
+
+  const matchesNegative = negative.some((p) => picomatch(p)(filePath));
+  return !matchesNegative;
+}
+
 /**
  * Check if a file path is allowed to be modified in the current phase.
  *
  * Rules:
  * - REFACTOR: everything allowed
- * - RED: files matching allowedRedPhaseFiles + free files (match neither set)
- * - GREEN: files matching allowedGreenPhaseFiles + free files
- * - Free files (matching neither glob set) are always allowed in all phases
+ * - RED: files in blockedInRed are blocked, everything else is free
+ * - GREEN: files in blockedInGreen are blocked, everything else is free
+ * - ! negation patterns exclude subsets from a block list
  */
 export function isAllowed(filePath: string, phase: Phase, config: Config): boolean {
   if (phase === "refactor") return true;
 
-  const matchesRed = config.allowedRedPhaseFiles.some((p) => picomatch(p)(filePath));
-  const matchesGreen = config.allowedGreenPhaseFiles.some((p) => picomatch(p)(filePath));
-
-  if (phase === "red") return matchesRed || (!matchesRed && !matchesGreen);
-  if (phase === "green") return matchesGreen || (!matchesRed && !matchesGreen);
-
-  return true;
+  const blocked = phase === "red" ? config.blockedInRed : config.blockedInGreen;
+  return !matchPatterns(blocked, filePath);
 }
 
 /**