@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/adapters/__tests__/linear-config.test.ts

@@ -0,0 +1,425 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+
+describe("Linear Config", () => {
+  const originalEnv = process.env.FLUX_PROJECT_ROOT;
+  const TEST_DIR = `${realpathSync(tmpdir())}/flux-linear-config-test-${Date.now()}`;
+  const FLUX_DIR = `${TEST_DIR}/.flux`;
+  const CONFIG_PATH = `${FLUX_DIR}/linear-config.json`;
+
+  beforeEach(async () => {
+    // Clean up any previous test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+
+    // Create test directory structure
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    // Set project root to test directory
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    // Clear the config cache
+    const { config } = await import("../../config.js");
+    config.clearCache();
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    if (originalEnv !== undefined) {
+      process.env.FLUX_PROJECT_ROOT = originalEnv;
+    } else {
+      delete process.env.FLUX_PROJECT_ROOT;
+    }
+
+    // Clear the config cache
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe("linearConfigExists", () => {
+    test("returns true when config file exists", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test",
+          teamId: "TEAM-123",
+          projectId: "proj_123",
+        }),
+      );
+
+      const { linearConfigExists } = await import("../linear/config.js");
+      expect(linearConfigExists()).toBe(true);
+    });
+
+    test("returns false when config file does not exist", async () => {
+      const { linearConfigExists } = await import("../linear/config.js");
+      expect(linearConfigExists()).toBe(false);
+    });
+  });
+
+  describe("validateLinearConfig", () => {
+    test("validates valid config with all fields", async () => {
+      const validConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(validConfig);
+
+      expect(result.apiKey).toBe("lin_api_test123");
+      expect(result.teamId).toBe("TEAM-123");
+      expect(result.projectId).toBe("proj_abc123");
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("validates valid config with optional defaultLabels omitted", async () => {
+      const validConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(validConfig);
+
+      expect(result.apiKey).toBe("lin_api_test123");
+      expect(result.teamId).toBe("TEAM-123");
+      expect(result.projectId).toBe("proj_abc123");
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("throws error when apiKey is missing", async () => {
+      const invalidConfig = {
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: apiKey is required",
+      );
+    });
+
+    test("throws error when teamId is missing", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+    });
+
+    test("throws error when projectId is missing", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: projectId is required",
+      );
+    });
+
+    test("throws error when config is not an object", async () => {
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(null)).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+      expect(() => validateLinearConfig("string")).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+      expect(() => validateLinearConfig(123)).toThrow(
+        "Invalid Linear config: must be an object",
+      );
+    });
+
+    test("throws error when apiKey is not a string", async () => {
+      const invalidConfig = {
+        apiKey: 123,
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: apiKey must be a string",
+      );
+    });
+
+    test("throws error when teamId is not a string", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        teamId: 123,
+        projectId: "proj_abc123",
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId must be a string",
+      );
+    });
+
+    test("throws error when projectId is not a string", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: 123,
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+
+      expect(() => validateLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: projectId must be a string",
+      );
+    });
+
+    test("uses default labels when defaultLabels is partially provided", async () => {
+      const configWithPartialLabels = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          epic: "custom-epic",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(configWithPartialLabels);
+
+      expect(result.defaultLabels.prd).toBe("prd");
+      expect(result.defaultLabels.epic).toBe("custom-epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+
+    test("allows custom prd label", async () => {
+      const configWithCustomPrdLabel = {
+        apiKey: "lin_api_test",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "custom-prd",
+        },
+      };
+
+      const { validateLinearConfig } = await import("../linear/config.js");
+      const result = validateLinearConfig(configWithCustomPrdLabel);
+
+      expect(result.defaultLabels.prd).toBe("custom-prd");
+      expect(result.defaultLabels.epic).toBe("epic");
+      expect(result.defaultLabels.task).toBe("task");
+    });
+  });
+
+  describe("loadLinearConfig", () => {
+    test("loads valid config from file", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          teamId: "TEAM-123",
+          projectId: "proj_abc123",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+      const config = loadLinearConfig();
+
+      expect(config.apiKey).toBe("lin_api_test123");
+      expect(config.teamId).toBe("TEAM-123");
+      expect(config.projectId).toBe("proj_abc123");
+      expect(config.defaultLabels.prd).toBe("prd");
+      expect(config.defaultLabels.epic).toBe("epic");
+      expect(config.defaultLabels.task).toBe("task");
+    });
+
+    test("loads config with default labels when not provided", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          teamId: "TEAM-123",
+          projectId: "proj_abc123",
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+      const config = loadLinearConfig();
+
+      expect(config.apiKey).toBe("lin_api_test123");
+      expect(config.teamId).toBe("TEAM-123");
+      expect(config.projectId).toBe("proj_abc123");
+      expect(config.defaultLabels.prd).toBe("prd");
+      expect(config.defaultLabels.epic).toBe("epic");
+      expect(config.defaultLabels.task).toBe("task");
+    });
+
+    test("throws error when config file does not exist", async () => {
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow(
+        "Linear config not found. Run configure_linear first.",
+      );
+    });
+
+    test("throws error when config file contains invalid JSON", async () => {
+      writeFileSync(CONFIG_PATH, "invalid json {");
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow();
+    });
+
+    test("throws error when config is missing required fields", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test123",
+          // missing teamId and projectId
+        }),
+      );
+
+      const { loadLinearConfig } = await import("../linear/config.js");
+
+      expect(() => loadLinearConfig()).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+    });
+  });
+
+  describe("saveLinearConfig", () => {
+    test("saves valid config to file", async () => {
+      const config = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(config);
+
+      expect(existsSync(CONFIG_PATH)).toBe(true);
+
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      expect(saved.apiKey).toBe("lin_api_test123");
+      expect(saved.teamId).toBe("TEAM-123");
+      expect(saved.projectId).toBe("proj_abc123");
+      expect(saved.defaultLabels.prd).toBe("prd");
+      expect(saved.defaultLabels.epic).toBe("epic");
+    });
+
+    test("creates .flux directory if it does not exist", async () => {
+      // Remove .flux directory
+      rmSync(FLUX_DIR, { recursive: true });
+
+      const config = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_abc123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(config);
+
+      expect(existsSync(FLUX_DIR)).toBe(true);
+      expect(existsSync(CONFIG_PATH)).toBe(true);
+    });
+
+    test("overwrites existing config file", async () => {
+      writeFileSync(
+        CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "old_api_key",
+          teamId: "OLD-TEAM",
+          projectId: "old_proj",
+        }),
+      );
+
+      const newConfig = {
+        apiKey: "new_api_key",
+        teamId: "NEW-TEAM",
+        projectId: "new_proj",
+        defaultLabels: {
+          prd: "custom-prd",
+          epic: "custom-epic",
+          task: "custom-task",
+        },
+      };
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+      saveLinearConfig(newConfig);
+
+      const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      expect(saved.apiKey).toBe("new_api_key");
+      expect(saved.teamId).toBe("NEW-TEAM");
+      expect(saved.projectId).toBe("new_proj");
+      expect(saved.defaultLabels.prd).toBe("custom-prd");
+      expect(saved.defaultLabels.epic).toBe("custom-epic");
+    });
+
+    test("validates config before saving", async () => {
+      const invalidConfig = {
+        apiKey: "lin_api_test",
+        // missing teamId and projectId
+      } as any;
+
+      const { saveLinearConfig } = await import("../linear/config.js");
+
+      expect(() => saveLinearConfig(invalidConfig)).toThrow(
+        "Invalid Linear config: teamId is required",
+      );
+
+      // Ensure file was not created
+      expect(existsSync(CONFIG_PATH)).toBe(false);
+    });
+  });
+});

package/src/server/adapters/__tests__/linear-criteria-parser.test.ts

@@ -0,0 +1,287 @@
+import { describe, expect, test } from "bun:test";
+import {
+  addCriterionToDescription,
+  generateCriteriaId,
+  parseCriteriaFromDescription,
+  updateCriterionInDescription,
+} from "../linear/helpers/criteria-parser.js";
+
+describe("criteria-parser", () => {
+  describe("generateCriteriaId", () => {
+    test("generates stable hash-based IDs", () => {
+      const id1 = generateCriteriaId("User can sign in");
+      const id2 = generateCriteriaId("User can sign in");
+      expect(id1).toBe(id2);
+    });
+
+    test("generates different IDs for different text", () => {
+      const id1 = generateCriteriaId("User can sign in");
+      const id2 = generateCriteriaId("User can sign out");
+      expect(id1).not.toBe(id2);
+    });
+
+    test("ID format is ac_ prefix with 8 hex chars", () => {
+      const id = generateCriteriaId("Test criterion");
+      expect(id).toMatch(/^ac_[a-f0-9]{8}$/);
+    });
+
+    test("trims whitespace for consistent IDs", () => {
+      const id1 = generateCriteriaId("  Test  ");
+      const id2 = generateCriteriaId("Test");
+      expect(id1).toBe(id2);
+    });
+  });
+
+  describe("parseCriteriaFromDescription", () => {
+    test("returns empty array for undefined description", () => {
+      const result = parseCriteriaFromDescription(undefined);
+      expect(result).toEqual([]);
+    });
+
+    test("returns empty array for empty description", () => {
+      const result = parseCriteriaFromDescription("");
+      expect(result).toEqual([]);
+    });
+
+    test("parses unchecked checkboxes with dash", () => {
+      const description = "- [ ] First item\n- [ ] Second item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+      expect(result[0].text).toBe("First item");
+      expect(result[0].isMet).toBe(false);
+      expect(result[1].text).toBe("Second item");
+      expect(result[1].isMet).toBe(false);
+    });
+
+    test("parses checked checkboxes with lowercase x", () => {
+      const description = "- [x] Completed item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Completed item");
+      expect(result[0].isMet).toBe(true);
+    });
+
+    test("parses checked checkboxes with uppercase X", () => {
+      const description = "- [X] Completed item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].isMet).toBe(true);
+    });
+
+    test("parses checkboxes with asterisk", () => {
+      const description = "* [ ] Item with asterisk";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Item with asterisk");
+    });
+
+    test("handles indented checkboxes", () => {
+      const description = "  - [ ] Indented item";
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(1);
+      expect(result[0].text).toBe("Indented item");
+    });
+
+    test("parses only AC section when header is present", () => {
+      const description = `# Overview
+Some overview text
+
+- [ ] Not a criterion
+
+## Acceptance Criteria
+
+- [ ] Real criterion 1
+- [x] Real criterion 2
+
+## Notes
+- [ ] Not a criterion either`;
+
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+      expect(result[0].text).toBe("Real criterion 1");
+      expect(result[1].text).toBe("Real criterion 2");
+    });
+
+    test("parses AC section with bold header", () => {
+      const description = `**Acceptance Criteria**
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**Notes**
+- [ ] Not a criterion`;
+
+      const result = parseCriteriaFromDescription(description);
+      expect(result).toHaveLength(2);
+    });
+
+    test("includes line index for updates", () => {
+      const description = "Header\n\n- [ ] Item 1\n- [ ] Item 2";
+      const result = parseCriteriaFromDescription(description);
+      expect(result[0].lineIndex).toBe(2);
+      expect(result[1].lineIndex).toBe(3);
+    });
+
+    test("generates correct IDs for criteria", () => {
+      const description = "- [ ] Test criterion";
+      const result = parseCriteriaFromDescription(description);
+      const expectedId = generateCriteriaId("Test criterion");
+      expect(result[0].id).toBe(expectedId);
+    });
+  });
+
+  describe("updateCriterionInDescription", () => {
+    test("marks criterion as met", () => {
+      const description = "- [ ] First item\n- [ ] Second item";
+      const criteriaId = generateCriteriaId("First item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("- [x] First item\n- [ ] Second item");
+    });
+
+    test("marks criterion as unmet", () => {
+      const description = "- [x] First item\n- [ ] Second item";
+      const criteriaId = generateCriteriaId("First item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        false,
+      );
+      expect(result).toBe("- [ ] First item\n- [ ] Second item");
+    });
+
+    test("preserves indentation", () => {
+      const description = "  - [ ] Indented item";
+      const criteriaId = generateCriteriaId("Indented item");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("  - [x] Indented item");
+    });
+
+    test("throws for non-existent criterion", () => {
+      const description = "- [ ] Item";
+      expect(() =>
+        updateCriterionInDescription(description, "ac_nonexist", true),
+      ).toThrow("Criterion not found");
+    });
+
+    test("updates correct criterion when multiple exist", () => {
+      const description = "- [ ] First\n- [ ] Second\n- [ ] Third";
+      const criteriaId = generateCriteriaId("Second");
+      const result = updateCriterionInDescription(
+        description,
+        criteriaId,
+        true,
+      );
+      expect(result).toBe("- [ ] First\n- [x] Second\n- [ ] Third");
+    });
+  });
+
+  describe("addCriterionToDescription", () => {
+    test("creates AC section for undefined description", () => {
+      const result = addCriterionToDescription(undefined, "New criterion");
+      expect(result).toBe("## Acceptance Criteria\n\n- [ ] New criterion");
+    });
+
+    test("creates AC section for empty description", () => {
+      const result = addCriterionToDescription("", "New criterion");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] New criterion");
+    });
+
+    test("adds to existing AC section", () => {
+      const description = `## Acceptance Criteria
+
+- [ ] Existing criterion`;
+
+      const result = addCriterionToDescription(description, "New criterion");
+      expect(result).toContain("- [ ] Existing criterion");
+      expect(result).toContain("- [ ] New criterion");
+    });
+
+    test("inserts after last checkbox in AC section", () => {
+      const description = `## Acceptance Criteria
+
+- [ ] First
+- [ ] Second
+
+## Notes
+Some notes`;
+
+      const result = addCriterionToDescription(description, "Third");
+      const lines = result.split("\n");
+      const thirdIndex = lines.findIndex((l) => l.includes("Third"));
+      const notesIndex = lines.findIndex((l) => l.includes("## Notes"));
+      expect(thirdIndex).toBeLessThan(notesIndex);
+    });
+
+    test("preserves description content before AC section", () => {
+      const description = `# Overview
+
+This is an overview.
+
+## Acceptance Criteria
+
+- [ ] Existing`;
+
+      const result = addCriterionToDescription(description, "New");
+      expect(result).toContain("# Overview");
+      expect(result).toContain("This is an overview.");
+    });
+
+    test("creates AC section at end if none exists", () => {
+      const description = `# Overview
+
+Some content here.`;
+
+      const result = addCriterionToDescription(description, "New criterion");
+      expect(result).toContain("# Overview");
+      expect(result).toContain("Some content here.");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] New criterion");
+    });
+  });
+
+  describe("integration: parse, update, parse cycle", () => {
+    test("round-trip preserves structure", () => {
+      const original = `## Acceptance Criteria
+
+- [ ] User can login
+- [ ] User can logout
+- [ ] Session persists`;
+
+      const parsed = parseCriteriaFromDescription(original);
+      expect(parsed).toHaveLength(3);
+
+      const updated = updateCriterionInDescription(
+        original,
+        parsed[1].id,
+        true,
+      );
+      const reParsed = parseCriteriaFromDescription(updated);
+
+      expect(reParsed).toHaveLength(3);
+      expect(reParsed[0].isMet).toBe(false);
+      expect(reParsed[1].isMet).toBe(true);
+      expect(reParsed[2].isMet).toBe(false);
+    });
+
+    test("add and parse cycle", () => {
+      let description = "## Overview\n\nSome text";
+
+      description = addCriterionToDescription(description, "First");
+      description = addCriterionToDescription(description, "Second");
+
+      const parsed = parseCriteriaFromDescription(description);
+      expect(parsed).toHaveLength(2);
+      expect(parsed.map((c) => c.text)).toContain("First");
+      expect(parsed.map((c) => c.text)).toContain("Second");
+    });
+  });
+});