@cliangdev/flux-plugin 0.2.0 → 0.3.0

package/src/server/adapters/__tests__/linear-mappers-description.test.ts

@@ -0,0 +1,276 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatDescription,
+  parseDescription,
+  updateAcCompletion,
+} from "../linear/mappers/description.js";
+
+describe("Description Formatters", () => {
+  describe("formatDescription", () => {
+    test("embeds acceptance criteria as markdown checklist", () => {
+      const result = formatDescription({
+        description: "This is the epic description.",
+        acceptanceCriteria: ["First criterion", "Second criterion"],
+      });
+
+      expect(result).toContain("This is the epic description.");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] First criterion");
+      expect(result).toContain("- [ ] Second criterion");
+    });
+
+    test("handles empty description with AC", () => {
+      const result = formatDescription({
+        acceptanceCriteria: ["Only criterion"],
+      });
+
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] Only criterion");
+      expect(result).not.toContain("undefined");
+    });
+
+    test("handles description with no AC", () => {
+      const result = formatDescription({
+        description: "Just a description",
+      });
+
+      expect(result).toBe("Just a description");
+      expect(result).not.toContain("## Acceptance Criteria");
+    });
+
+    test("handles empty AC array", () => {
+      const result = formatDescription({
+        description: "Description only",
+        acceptanceCriteria: [],
+      });
+
+      expect(result).toBe("Description only");
+      expect(result).not.toContain("## Acceptance Criteria");
+    });
+
+    test("does not duplicate AC section if already present", () => {
+      const existing = `Description text.
+
+## Acceptance Criteria
+- [ ] Existing criterion`;
+
+      const result = formatDescription({
+        description: existing,
+        acceptanceCriteria: ["New criterion"],
+      });
+
+      // Should replace existing AC section
+      expect(result).toContain("- [ ] New criterion");
+      expect(result).not.toContain("Existing criterion");
+
+      // Should only have one AC section
+      const matches = result.match(/## Acceptance Criteria/g);
+      expect(matches).toHaveLength(1);
+    });
+
+    test("preserves newlines in description before AC section", () => {
+      const result = formatDescription({
+        description: "Line 1\n\nLine 2\n\nLine 3",
+        acceptanceCriteria: ["Criterion"],
+      });
+
+      expect(result).toContain("Line 1\n\nLine 2\n\nLine 3");
+      expect(result).toContain("## Acceptance Criteria");
+      expect(result).toContain("- [ ] Criterion");
+    });
+  });
+
+  describe("parseDescription", () => {
+    test("extracts AC from description", () => {
+      const content = `This is the description.
+
+## Acceptance Criteria
+- [ ] First criterion
+- [ ] Second criterion`;
+
+      const result = parseDescription(content);
+
+      expect(result.description).toBe("This is the description.");
+      expect(result.acceptanceCriteria).toHaveLength(2);
+      expect(result.acceptanceCriteria[0]).toEqual({
+        text: "First criterion",
+        isCompleted: false,
+      });
+      expect(result.acceptanceCriteria[1]).toEqual({
+        text: "Second criterion",
+        isCompleted: false,
+      });
+    });
+
+    test("extracts completed AC", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [x] Completed criterion
+- [ ] Pending criterion`;
+
+      const result = parseDescription(content);
+
+      expect(result.acceptanceCriteria).toHaveLength(2);
+      expect(result.acceptanceCriteria[0]).toEqual({
+        text: "Completed criterion",
+        isCompleted: true,
+      });
+      expect(result.acceptanceCriteria[1]).toEqual({
+        text: "Pending criterion",
+        isCompleted: false,
+      });
+    });
+
+    test("handles description without AC section", () => {
+      const content = "Just a plain description.";
+
+      const result = parseDescription(content);
+
+      expect(result.description).toBe("Just a plain description.");
+      expect(result.acceptanceCriteria).toHaveLength(0);
+    });
+
+    test("handles empty description", () => {
+      const result = parseDescription("");
+
+      expect(result.description).toBe("");
+      expect(result.acceptanceCriteria).toHaveLength(0);
+    });
+
+    test("handles AC section with no items", () => {
+      const content = `Description.
+
+## Acceptance Criteria`;
+
+      const result = parseDescription(content);
+
+      expect(result.description).toBe("Description.");
+      expect(result.acceptanceCriteria).toHaveLength(0);
+    });
+
+    test("trims whitespace from description", () => {
+      const content = `  Description text
+
+## Acceptance Criteria
+- [ ] Criterion`;
+
+      const result = parseDescription(content);
+
+      expect(result.description).toBe("Description text");
+    });
+
+    test("handles various checkbox formats", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [x] Completed with x
+- [X] Completed with X
+- [ ] Pending
+-  [ ]  Extra spaces
+- [  ] Empty checkbox`;
+
+      const result = parseDescription(content);
+
+      expect(result.acceptanceCriteria).toHaveLength(5);
+      expect(result.acceptanceCriteria[0].isCompleted).toBe(true);
+      expect(result.acceptanceCriteria[1].isCompleted).toBe(true);
+      expect(result.acceptanceCriteria[2].isCompleted).toBe(false);
+      expect(result.acceptanceCriteria[3].isCompleted).toBe(false);
+      expect(result.acceptanceCriteria[4].isCompleted).toBe(false);
+    });
+
+    test("preserves multi-line description before AC section", () => {
+      const content = `First line.
+
+Second paragraph.
+
+Third paragraph.
+
+## Acceptance Criteria
+- [ ] Criterion`;
+
+      const result = parseDescription(content);
+
+      expect(result.description).toBe(
+        "First line.\n\nSecond paragraph.\n\nThird paragraph.",
+      );
+    });
+  });
+
+  describe("updateAcCompletion", () => {
+    test("marks AC as completed", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [ ] First criterion
+- [ ] Second criterion`;
+
+      const result = updateAcCompletion(content, "First criterion", true);
+
+      expect(result).toContain("- [x] First criterion");
+      expect(result).toContain("- [ ] Second criterion");
+    });
+
+    test("marks AC as incomplete", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [x] First criterion
+- [x] Second criterion`;
+
+      const result = updateAcCompletion(content, "Second criterion", false);
+
+      expect(result).toContain("- [x] First criterion");
+      expect(result).toContain("- [ ] Second criterion");
+    });
+
+    test("handles partial text matches by exact match only", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [ ] Test criterion
+- [ ] Test criterion extended`;
+
+      const result = updateAcCompletion(content, "Test criterion", true);
+
+      expect(result).toContain("- [x] Test criterion\n");
+      expect(result).toContain("- [ ] Test criterion extended");
+    });
+
+    test("returns content unchanged if AC not found", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [ ] First criterion`;
+
+      const result = updateAcCompletion(content, "Nonexistent", true);
+
+      expect(result).toBe(content);
+    });
+
+    test("returns content unchanged if no AC section", () => {
+      const content = "Just a description.";
+
+      const result = updateAcCompletion(content, "Anything", true);
+
+      expect(result).toBe(content);
+    });
+
+    test("handles multiple updates", () => {
+      const content = `Description.
+
+## Acceptance Criteria
+- [ ] First criterion
+- [ ] Second criterion
+- [ ] Third criterion`;
+
+      let result = updateAcCompletion(content, "First criterion", true);
+      result = updateAcCompletion(result, "Third criterion", true);
+
+      expect(result).toContain("- [x] First criterion");
+      expect(result).toContain("- [ ] Second criterion");
+      expect(result).toContain("- [x] Third criterion");
+    });
+  });
+});

package/src/server/adapters/__tests__/linear-mappers-epic.test.ts

@@ -0,0 +1,294 @@
+import { describe, expect, test } from "bun:test";
+// Import mapper functions - these will be implemented
+import {
+  isEpicIssue,
+  toEpic,
+  toFluxEpicStatus,
+  toLinearEpicState,
+} from "../linear/mappers/epic.js";
+import type { LinearIssue } from "../linear/types.js";
+import type { Epic } from "../types.js";
+
+describe("Epic Mapper", () => {
+  describe("isEpicIssue", () => {
+    test("returns true when issue has epic label", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "Epic Issue",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+        labels: [
+          { id: "label_1", name: "epic" },
+          { id: "label_2", name: "backend" },
+        ],
+      };
+
+      expect(isEpicIssue(issue, "epic")).toBe(true);
+    });
+
+    test("returns false when issue does not have epic label", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "Regular Issue",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+        labels: [{ id: "label_2", name: "backend" }],
+      };
+
+      expect(isEpicIssue(issue, "epic")).toBe(false);
+    });
+
+    test("returns false when issue has no labels", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "Regular Issue",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      expect(isEpicIssue(issue, "epic")).toBe(false);
+    });
+
+    test("matches custom epic label name", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "Epic Issue",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+        labels: [{ id: "label_1", name: "feature-epic" }],
+      };
+
+      expect(isEpicIssue(issue, "feature-epic")).toBe(true);
+      expect(isEpicIssue(issue, "epic")).toBe(false);
+    });
+  });
+
+  describe("toFluxEpicStatus", () => {
+    test("maps Backlog to PENDING", () => {
+      expect(toFluxEpicStatus("Backlog")).toBe("PENDING");
+    });
+
+    test("maps In Progress to IN_PROGRESS", () => {
+      expect(toFluxEpicStatus("In Progress")).toBe("IN_PROGRESS");
+    });
+
+    test("maps Done to COMPLETED", () => {
+      expect(toFluxEpicStatus("Done")).toBe("COMPLETED");
+    });
+
+    test("defaults to PENDING for unknown states", () => {
+      expect(toFluxEpicStatus("Unknown State")).toBe("PENDING");
+      expect(toFluxEpicStatus("Canceled")).toBe("PENDING");
+      expect(toFluxEpicStatus("")).toBe("PENDING");
+    });
+
+    test("is case-sensitive", () => {
+      expect(toFluxEpicStatus("backlog")).toBe("PENDING"); // lowercase
+      expect(toFluxEpicStatus("BACKLOG")).toBe("PENDING"); // uppercase
+      expect(toFluxEpicStatus("in progress")).toBe("PENDING"); // wrong case
+    });
+  });
+
+  describe("toLinearEpicState", () => {
+    test("maps PENDING to Todo", () => {
+      expect(toLinearEpicState("PENDING")).toBe("Todo");
+    });
+
+    test("maps IN_PROGRESS to In Progress", () => {
+      expect(toLinearEpicState("IN_PROGRESS")).toBe("In Progress");
+    });
+
+    test("maps COMPLETED to Done", () => {
+      expect(toLinearEpicState("COMPLETED")).toBe("Done");
+    });
+  });
+
+  describe("toEpic", () => {
+    test("transforms Linear Issue to Flux Epic with PENDING status", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "User Authentication Epic",
+        description: "Implement user auth system",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        projectId: "proj_abc123",
+        createdAt: "2024-01-01T10:00:00Z",
+        updatedAt: "2024-01-02T15:30:00Z",
+        labels: [{ id: "label_1", name: "epic" }],
+      };
+
+      const prdId = "prd_xyz789";
+      const epic: Epic = toEpic(linearIssue, prdId);
+
+      expect(epic.id).toBe("issue_123");
+      expect(epic.prdId).toBe("prd_xyz789");
+      expect(epic.ref).toBe("ENG-42");
+      expect(epic.title).toBe("User Authentication Epic");
+      expect(epic.description).toBe("Implement user auth system");
+      expect(epic.status).toBe("PENDING");
+      expect(epic.createdAt).toBe("2024-01-01T10:00:00Z");
+      expect(epic.updatedAt).toBe("2024-01-02T15:30:00Z");
+    });
+
+    test("transforms Linear Issue to Flux Epic with IN_PROGRESS status", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_124",
+        identifier: "ENG-43",
+        title: "API Development",
+        description: "Build REST API",
+        state: {
+          id: "state_2",
+          name: "In Progress",
+          type: "started",
+        },
+        priority: 2,
+        projectId: "proj_abc123",
+        createdAt: "2024-01-03T10:00:00Z",
+        updatedAt: "2024-01-04T15:30:00Z",
+      };
+
+      const epic: Epic = toEpic(linearIssue, "prd_xyz789");
+
+      expect(epic.id).toBe("issue_124");
+      expect(epic.ref).toBe("ENG-43");
+      expect(epic.status).toBe("IN_PROGRESS");
+    });
+
+    test("transforms Linear Issue to Flux Epic with COMPLETED status", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_125",
+        identifier: "ENG-44",
+        title: "Database Setup",
+        state: {
+          id: "state_3",
+          name: "Done",
+          type: "completed",
+        },
+        priority: 2,
+        createdAt: "2024-01-05T10:00:00Z",
+        updatedAt: "2024-01-06T15:30:00Z",
+      };
+
+      const epic: Epic = toEpic(linearIssue, "prd_xyz789");
+
+      expect(epic.id).toBe("issue_125");
+      expect(epic.ref).toBe("ENG-44");
+      expect(epic.status).toBe("COMPLETED");
+    });
+
+    test("handles missing optional description", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_126",
+        identifier: "ENG-45",
+        title: "Epic without description",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-07T10:00:00Z",
+        updatedAt: "2024-01-08T15:30:00Z",
+      };
+
+      const epic: Epic = toEpic(linearIssue, "prd_xyz789");
+
+      expect(epic.description).toBeUndefined();
+    });
+
+    test("uses Linear issue ID as Flux Epic ID", () => {
+      const linearIssue: LinearIssue = {
+        id: "unique_linear_id_123",
+        identifier: "ENG-46",
+        title: "Test Epic",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-09T10:00:00Z",
+        updatedAt: "2024-01-10T15:30:00Z",
+      };
+
+      const epic: Epic = toEpic(linearIssue, "prd_xyz789");
+
+      expect(epic.id).toBe("unique_linear_id_123");
+    });
+
+    test("uses Linear identifier as Flux Epic ref", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_127",
+        identifier: "TEAM-999",
+        title: "Test Epic",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-11T10:00:00Z",
+        updatedAt: "2024-01-12T15:30:00Z",
+      };
+
+      const epic: Epic = toEpic(linearIssue, "prd_xyz789");
+
+      expect(epic.ref).toBe("TEAM-999");
+    });
+
+    test("associates epic with provided prdId", () => {
+      const linearIssue: LinearIssue = {
+        id: "issue_128",
+        identifier: "ENG-47",
+        title: "Test Epic",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 2,
+        createdAt: "2024-01-13T10:00:00Z",
+        updatedAt: "2024-01-14T15:30:00Z",
+      };
+
+      const epic1: Epic = toEpic(linearIssue, "prd_first");
+      const epic2: Epic = toEpic(linearIssue, "prd_second");
+
+      expect(epic1.prdId).toBe("prd_first");
+      expect(epic2.prdId).toBe("prd_second");
+    });
+  });
+});