feat: Add Pattern Server with REST API and comprehensive test suite

Implemented a complete Pattern Server + CLI workflow with full test coverage:

## Pattern Server (server/index.ts)
- GET /health - Health check endpoint
- GET /api/v1/rules - List all Effect patterns
- GET /api/v1/rules/:id - Get single pattern by ID
- Schema validation with Effect Schema
- Tagged error handling (RuleNotFoundError, RuleLoadError, etc.)
- Structured logging for all requests

## CLI Tool (scripts/ep.ts)
- `ep rules add --tool cursor` command
- Fetches rules from Pattern Server API
- Injects into .cursor/rules.md with managed block markers
- Preserves user content outside managed blocks
- Uses FetchHttpClient for Bun compatibility

## Test Suite (37 tests, 100% passing)
- server/server.test.ts: 10 API endpoint tests
- scripts/ep-rules-add.test.ts: 18 CLI command tests
- scripts/integration.test.ts: 9 E2E integration tests
- vitest.config.ts: Sequential execution for test isolation
- Tests cover: API validation, CLI operations, E2E flows, error handling

All tests use Effect-based HTTP clients and proper server lifecycle management.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: PaulJPhilp

package.json

@@ -5,6 +5,7 @@
   "private": true,
   "description": "A community-driven knowledge base for Effect-TS patterns.",
   "scripts": {
+    "ep": "bun run scripts/ep.ts",
     "publish": "bun run scripts/publish/publish.ts",
     "validate": "bun run scripts/publish/validate-improved.ts",
     "validate:simple": "bun run scripts/publish/validate.ts",
@@ -19,6 +20,7 @@
     "lint:all": "bun run lint && bun run lint:effect",
     "rules": "bun run scripts/publish/rules-improved.ts",
     "rules:simple": "bun run scripts/publish/rules.ts",
+    "rules:claude": "bun run scripts/publish/generate-claude-rules.ts",
     "ingest": "bun run scripts/ingest/ingest-pipeline-improved.ts",
     "ingest:old": "bun run scripts/ingest/process.ts",
     "pipeline": "bun run scripts/publish/pipeline.ts",
@@ -38,7 +40,12 @@
     "qa:status": "bun run scripts/qa/qa-status.ts",
     "qa:repair:dry": "bun run scripts/qa/qa-repair.ts --dry-run",
     "qa:all": "./scripts/qa/qa-process.sh && bun run qa:report",
-    "qa:test": "bun run scripts/qa/test-enhanced-qa.ts"
+    "qa:test": "bun run scripts/qa/test-enhanced-qa.ts",
+    "server:dev": "bun --watch server/index.ts",
+    "test:server": "vitest run server",
+    "test:cli": "vitest run scripts/ep-rules-add.test.ts",
+    "test:e2e": "vitest run scripts/integration.test.ts",
+    "test:api": "vitest run server scripts/ep-rules-add.test.ts scripts/integration.test.ts"
   },
   "dependencies": {
     "@effect/ai": "^0.25.2",
@@ -59,13 +66,17 @@
     "@opentelemetry/sdk-trace-node": "^2.1.0",
     "@opentelemetry/semantic-conventions": "^1.37.0",
     "cli-table3": "^0.6.5",
+    "conventional-commits-parser": "^6.2.0",
+    "conventional-recommended-bump": "^11.2.0",
     "dotenv": "^17.2.2",
     "effect": "^3.17.14",
     "effect-mdx": "^0.1.0",
+    "glob": "^11.0.3",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
     "liquidjs": "^10.21.1",
     "process": "^0.11.10",
+    "semver": "^7.7.2",
     "yaml": "^2.8.1"
   },
   "devDependencies": {

scripts/ep-rules-add.test.ts

@@ -0,0 +1,309 @@
+/**
+ * ep rules add Command Tests
+ *
+ * Comprehensive test suite for the CLI rules add command
+ */
+
+import { FileSystem } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
+import { Effect } from "effect";
+import { describe, expect, it, beforeEach, afterEach } from "vitest";
+import { spawn, type ChildProcess } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// --- TEST UTILITIES ---
+
+let serverProcess: ChildProcess | null = null;
+
+const startServer = async () => {
+  serverProcess = spawn("bun", ["run", "server/index.ts"], {
+    stdio: "pipe",
+  });
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+};
+
+const stopServer = () => {
+  if (serverProcess) {
+    serverProcess.kill();
+    serverProcess = null;
+  }
+};
+
+const runCommand = async (args: string[]): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+  return new Promise((resolve) => {
+    const proc = spawn("bun", ["run", "scripts/ep.ts", ...args], {
+      stdio: "pipe",
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      resolve({ stdout, stderr, exitCode: code || 0 });
+    });
+  });
+};
+
+const TEST_DIR = ".cursor-test";
+const TEST_FILE = path.join(TEST_DIR, "rules.md");
+
+// --- TESTS ---
+
+describe.sequential("ep rules add command", () => {
+  beforeEach(async () => {
+    // Start server before each test
+    await startServer();
+
+    // Clean up test directory
+    try {
+      await fs.rm(TEST_DIR, { recursive: true });
+    } catch {}
+  });
+
+  afterEach(async () => {
+    // Stop server after each test
+    stopServer();
+
+    // Clean up test directory
+    try {
+      await fs.rm(TEST_DIR, { recursive: true });
+    } catch {}
+  });
+
+  describe("Tool Validation", () => {
+    it("should require --tool option", async () => {
+      const result = await runCommand(["rules", "add"]);
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toContain("tool");
+    });
+
+    it("should reject unsupported tools", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "windsurf"]);
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stdout).toContain("not supported");
+      expect(result.stdout).toContain("windsurf");
+    });
+
+    it("should accept cursor tool", async () => {
+      // Override target file for test
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("Fetching rules");
+    });
+  });
+
+  describe("API Integration", () => {
+    it("should fetch rules from server", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("Fetched");
+      expect(result.stdout).toContain("rules");
+    });
+
+    it("should handle server unavailable gracefully", async () => {
+      // Stop server first
+      stopServer();
+
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stdout).toContain("Failed to fetch");
+    });
+  });
+
+  describe("File Operations", () => {
+    it("should create .cursor directory if not exists", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+
+      // Check directory was created
+      const dirExists = await fs.stat(".cursor")
+        .then(() => true)
+        .catch(() => false);
+
+      expect(dirExists).toBe(true);
+    });
+
+    it("should create rules.md file", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+
+      // Check file was created
+      const fileExists = await fs.stat(".cursor/rules.md")
+        .then(() => true)
+        .catch(() => false);
+
+      expect(fileExists).toBe(true);
+    });
+
+    it("should include managed block markers", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+
+      const content = await fs.readFile(".cursor/rules.md", "utf-8");
+
+      expect(content).toContain("# --- BEGIN EFFECTPATTERNS RULES ---");
+      expect(content).toContain("# --- END EFFECTPATTERNS RULES ---");
+    });
+
+    it("should format rules correctly", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+
+      const content = await fs.readFile(".cursor/rules.md", "utf-8");
+
+      // Check for rule formatting
+      expect(content).toContain("###");
+      expect(content).toContain("**ID:**");
+      expect(content).toContain("**Use Case:**");
+      expect(content).toContain("**Skill Level:**");
+    });
+  });
+
+  describe("Update Behavior", () => {
+    it("should replace existing managed block", async () => {
+      // Create initial file
+      await fs.mkdir(".cursor", { recursive: true });
+      const initialContent = `# My Custom Rules
+
+Some custom content here
+
+# --- BEGIN EFFECTPATTERNS RULES ---
+Old rules content
+# --- END EFFECTPATTERNS RULES ---
+
+More custom content`;
+
+      await fs.writeFile(".cursor/rules.md", initialContent);
+
+      // Run command
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+      expect(result.exitCode).toBe(0);
+
+      // Check content
+      const content = await fs.readFile(".cursor/rules.md", "utf-8");
+
+      // Should preserve custom content
+      expect(content).toContain("My Custom Rules");
+      expect(content).toContain("Some custom content here");
+      expect(content).toContain("More custom content");
+
+      // Should replace managed block
+      expect(content).not.toContain("Old rules content");
+      expect(content).toContain("# --- BEGIN EFFECTPATTERNS RULES ---");
+      expect(content).toContain("# --- END EFFECTPATTERNS RULES ---");
+    });
+
+    it("should append managed block if not present", async () => {
+      // Create initial file without managed block
+      await fs.mkdir(".cursor", { recursive: true });
+      const initialContent = `# My Custom Rules
+
+Some custom content here`;
+
+      await fs.writeFile(".cursor/rules.md", initialContent);
+
+      // Run command
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+      expect(result.exitCode).toBe(0);
+
+      // Check content
+      const content = await fs.readFile(".cursor/rules.md", "utf-8");
+
+      // Should preserve custom content
+      expect(content).toContain("My Custom Rules");
+      expect(content).toContain("Some custom content here");
+
+      // Should add managed block
+      expect(content).toContain("# --- BEGIN EFFECTPATTERNS RULES ---");
+      expect(content).toContain("# --- END EFFECTPATTERNS RULES ---");
+    });
+  });
+
+  describe("Output Messages", () => {
+    it("should show progress messages", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain("Fetching rules");
+      expect(result.stdout).toContain("Injecting rules");
+      expect(result.stdout).toContain("Successfully added");
+      expect(result.stdout).toContain("Rules integration complete");
+    });
+
+    it("should show rule count", async () => {
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toMatch(/Fetched \d+ rules/);
+      expect(result.stdout).toMatch(/Successfully added \d+ rules/);
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle file system errors", async () => {
+      // Clean up .cursor directory if it exists
+      try {
+        await fs.rm(".cursor", { recursive: true });
+      } catch {}
+
+      // Create a file where directory should be
+      await fs.writeFile(".cursor", "This is a file, not a directory");
+
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      // Should fail due to file system error
+      expect(result.exitCode).not.toBe(0);
+
+      // Clean up the file
+      await fs.unlink(".cursor");
+    });
+
+    it("should show helpful error messages", async () => {
+      stopServer();
+
+      const result = await runCommand(["rules", "add", "--tool", "cursor"]);
+
+      expect(result.stdout).toContain("Make sure the Pattern Server is running");
+      expect(result.stdout).toContain("bun run server:dev");
+    });
+  });
+});
+
+describe.sequential("ep rules command structure", () => {
+  it("should have rules subcommand", async () => {
+    const result = await runCommand(["rules", "--help"]);
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain("rules");
+  });
+
+  it("should have add subcommand", async () => {
+    const result = await runCommand(["rules", "--help"]);
+
+    expect(result.stdout).toContain("add");
+  });
+
+  it("should have generate subcommand", async () => {
+    const result = await runCommand(["rules", "--help"]);
+
+    expect(result.stdout).toContain("generate");
+  });
+});