@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,300 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isPrdIssue,
+  toFluxPrdStatus,
+  toFluxPrdStatusFromIssue,
+  toLinearPrdIssueState,
+  toLinearProjectState,
+  toPrd,
+  toPrdFromIssue,
+} from "../linear/mappers/prd.js";
+import type { LinearIssue, LinearProject } from "../linear/types.js";
+import type { PrdStatus } from "../types.js";
+
+describe("PRD Mapper", () => {
+  // ===========================================================================
+  // Issue-based PRD mapping (new approach)
+  // ===========================================================================
+
+  describe("toPrdFromIssue", () => {
+    test("transforms Linear Issue to Flux Prd", () => {
+      const issue: LinearIssue = {
+        id: "issue_abc123",
+        identifier: "ENG-42",
+        title: "User Authentication",
+        description: "Implement user login and registration",
+        state: { id: "state_1", name: "In Progress", type: "started" },
+        priority: 3,
+        labels: [{ id: "label_1", name: "prd" }],
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      const prd = toPrdFromIssue(issue, "proj_xyz");
+
+      expect(prd.id).toBe("issue_abc123");
+      expect(prd.projectId).toBe("proj_xyz");
+      expect(prd.ref).toBe("ENG-42");
+      expect(prd.title).toBe("User Authentication");
+      expect(prd.description).toBe("Implement user login and registration");
+      expect(prd.status).toBe("APPROVED"); // In Progress -> APPROVED
+      expect(prd.createdAt).toBe("2024-01-01T00:00:00Z");
+      expect(prd.updatedAt).toBe("2024-01-02T00:00:00Z");
+    });
+
+    test("handles issue without description", () => {
+      const issue: LinearIssue = {
+        id: "issue_xyz",
+        identifier: "ENG-99",
+        title: "Test PRD",
+        state: { id: "state_1", name: "Backlog", type: "backlog" },
+        priority: 3,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const prd = toPrdFromIssue(issue, "proj_xyz");
+
+      expect(prd.title).toBe("Test PRD");
+      expect(prd.description).toBeUndefined();
+      expect(prd.status).toBe("DRAFT"); // Backlog -> DRAFT
+    });
+  });
+
+  describe("isPrdIssue", () => {
+    test("returns true when issue has prd label", () => {
+      const issue: LinearIssue = {
+        id: "issue_1",
+        identifier: "ENG-1",
+        title: "Test",
+        state: { id: "state_1", name: "Backlog", type: "backlog" },
+        priority: 3,
+        labels: [{ id: "label_1", name: "prd" }],
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      expect(isPrdIssue(issue, "prd")).toBe(true);
+    });
+
+    test("returns false when issue has no prd label", () => {
+      const issue: LinearIssue = {
+        id: "issue_1",
+        identifier: "ENG-1",
+        title: "Test",
+        state: { id: "state_1", name: "Backlog", type: "backlog" },
+        priority: 3,
+        labels: [{ id: "label_1", name: "epic" }],
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      expect(isPrdIssue(issue, "prd")).toBe(false);
+    });
+
+    test("returns false when issue has no labels", () => {
+      const issue: LinearIssue = {
+        id: "issue_1",
+        identifier: "ENG-1",
+        title: "Test",
+        state: { id: "state_1", name: "Backlog", type: "backlog" },
+        priority: 3,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      expect(isPrdIssue(issue, "prd")).toBe(false);
+    });
+
+    test("uses custom label name", () => {
+      const issue: LinearIssue = {
+        id: "issue_1",
+        identifier: "ENG-1",
+        title: "Test",
+        state: { id: "state_1", name: "Backlog", type: "backlog" },
+        priority: 3,
+        labels: [{ id: "label_1", name: "custom-prd" }],
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      expect(isPrdIssue(issue, "custom-prd")).toBe(true);
+      expect(isPrdIssue(issue, "prd")).toBe(false);
+    });
+  });
+
+  describe("toFluxPrdStatusFromIssue", () => {
+    test("maps Backlog to DRAFT", () => {
+      expect(toFluxPrdStatusFromIssue("Backlog")).toBe("DRAFT");
+    });
+
+    test("maps In Progress to APPROVED", () => {
+      expect(toFluxPrdStatusFromIssue("In Progress")).toBe("APPROVED");
+    });
+
+    test("maps Done to COMPLETED", () => {
+      expect(toFluxPrdStatusFromIssue("Done")).toBe("COMPLETED");
+    });
+
+    test("maps Canceled to ARCHIVED", () => {
+      expect(toFluxPrdStatusFromIssue("Canceled")).toBe("ARCHIVED");
+    });
+
+    test("defaults to DRAFT for unknown state", () => {
+      expect(toFluxPrdStatusFromIssue("Unknown")).toBe("DRAFT");
+    });
+  });
+
+  describe("toLinearPrdIssueState", () => {
+    test("maps DRAFT to Backlog", () => {
+      expect(toLinearPrdIssueState("DRAFT")).toBe("Backlog");
+    });
+
+    test("maps PENDING_REVIEW to Todo", () => {
+      expect(toLinearPrdIssueState("PENDING_REVIEW")).toBe("Todo");
+    });
+
+    test("maps REVIEWED to Todo", () => {
+      expect(toLinearPrdIssueState("REVIEWED")).toBe("Todo");
+    });
+
+    test("maps APPROVED to In Progress", () => {
+      expect(toLinearPrdIssueState("APPROVED")).toBe("In Progress");
+    });
+
+    test("maps BREAKDOWN_READY to In Progress", () => {
+      expect(toLinearPrdIssueState("BREAKDOWN_READY")).toBe("In Progress");
+    });
+
+    test("maps COMPLETED to Done", () => {
+      expect(toLinearPrdIssueState("COMPLETED")).toBe("Done");
+    });
+
+    test("maps ARCHIVED to Canceled", () => {
+      expect(toLinearPrdIssueState("ARCHIVED")).toBe("Canceled");
+    });
+  });
+
+  // ===========================================================================
+  // Project-based PRD mapping (deprecated but kept for backward compatibility)
+  // ===========================================================================
+
+  describe("toPrd (deprecated)", () => {
+    test("transforms Linear Project to Flux Prd", () => {
+      const project: LinearProject = {
+        id: "proj_abc123",
+        name: "User Authentication",
+        description: "Implement user login and registration",
+        state: "started",
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      const prd = toPrd(project, "proj_abc123");
+
+      expect(prd.id).toBe("proj_abc123");
+      expect(prd.projectId).toBe("proj_abc123");
+      expect(prd.ref).toBe("proj_abc123");
+      expect(prd.title).toBe("User Authentication");
+      expect(prd.description).toBe("Implement user login and registration");
+      expect(prd.status).toBe("APPROVED"); // started -> APPROVED
+      expect(prd.createdAt).toBe("2024-01-01T00:00:00Z");
+      expect(prd.updatedAt).toBe("2024-01-02T00:00:00Z");
+    });
+
+    test("handles project without description", () => {
+      const project: LinearProject = {
+        id: "proj_xyz",
+        name: "Test Project",
+        state: "backlog",
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const prd = toPrd(project, "proj_xyz");
+
+      expect(prd.title).toBe("Test Project");
+      expect(prd.description).toBeUndefined();
+      expect(prd.status).toBe("DRAFT"); // backlog -> DRAFT
+    });
+
+    test("maps all Linear project states to Flux statuses", () => {
+      const states: Array<{ linear: string; flux: PrdStatus }> = [
+        { linear: "backlog", flux: "DRAFT" },
+        { linear: "planned", flux: "PENDING_REVIEW" },
+        { linear: "started", flux: "APPROVED" },
+        { linear: "completed", flux: "COMPLETED" },
+        { linear: "canceled", flux: "ARCHIVED" },
+      ];
+
+      for (const { linear, flux } of states) {
+        const project: LinearProject = {
+          id: "proj_test",
+          name: "Test",
+          state: linear,
+          createdAt: "2024-01-01T00:00:00Z",
+          updatedAt: "2024-01-01T00:00:00Z",
+        };
+
+        const prd = toPrd(project, "proj_test");
+        expect(prd.status).toBe(flux);
+      }
+    });
+  });
+
+  describe("toLinearProjectState (deprecated)", () => {
+    test("maps DRAFT to backlog", () => {
+      expect(toLinearProjectState("DRAFT")).toBe("backlog");
+    });
+
+    test("maps PENDING_REVIEW to planned", () => {
+      expect(toLinearProjectState("PENDING_REVIEW")).toBe("planned");
+    });
+
+    test("maps REVIEWED to planned", () => {
+      expect(toLinearProjectState("REVIEWED")).toBe("planned");
+    });
+
+    test("maps APPROVED to started", () => {
+      expect(toLinearProjectState("APPROVED")).toBe("started");
+    });
+
+    test("maps BREAKDOWN_READY to started", () => {
+      expect(toLinearProjectState("BREAKDOWN_READY")).toBe("started");
+    });
+
+    test("maps COMPLETED to completed", () => {
+      expect(toLinearProjectState("COMPLETED")).toBe("completed");
+    });
+
+    test("maps ARCHIVED to canceled", () => {
+      expect(toLinearProjectState("ARCHIVED")).toBe("canceled");
+    });
+  });
+
+  describe("toFluxPrdStatus (deprecated)", () => {
+    test("maps backlog to DRAFT", () => {
+      expect(toFluxPrdStatus("backlog")).toBe("DRAFT");
+    });
+
+    test("maps planned to PENDING_REVIEW", () => {
+      expect(toFluxPrdStatus("planned")).toBe("PENDING_REVIEW");
+    });
+
+    test("maps started to APPROVED", () => {
+      expect(toFluxPrdStatus("started")).toBe("APPROVED");
+    });
+
+    test("maps completed to COMPLETED", () => {
+      expect(toFluxPrdStatus("completed")).toBe("COMPLETED");
+    });
+
+    test("maps canceled to ARCHIVED", () => {
+      expect(toFluxPrdStatus("canceled")).toBe("ARCHIVED");
+    });
+
+    test("defaults to DRAFT for unknown state", () => {
+      expect(toFluxPrdStatus("unknown")).toBe("DRAFT");
+    });
+  });
+});

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

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import {
+  toFluxPriority,
+  toFluxTaskStatus,
+  toLinearPriority,
+  toLinearTaskState,
+  toTask,
+} from "../linear/mappers/task.js";
+import type { LinearIssue } from "../linear/types.js";
+
+describe("Linear Task Mapper", () => {
+  describe("toTask", () => {
+    test("transforms Linear Issue to Flux Task with all fields", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-43",
+        title: "Implement login API",
+        description: "Add authentication endpoint",
+        state: {
+          id: "state_1",
+          name: "In Progress",
+          type: "started",
+        },
+        priority: 2, // HIGH in Flux
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      const task = toTask(issue, "epic-123");
+
+      expect(task.id).toBe("issue_123");
+      expect(task.epicId).toBe("epic-123");
+      expect(task.ref).toBe("ENG-43");
+      expect(task.title).toBe("Implement login API");
+      expect(task.description).toBe("Add authentication endpoint");
+      expect(task.status).toBe("IN_PROGRESS");
+      expect(task.priority).toBe("HIGH");
+      expect(task.createdAt).toBe("2024-01-01T00:00:00Z");
+      expect(task.updatedAt).toBe("2024-01-02T00:00:00Z");
+    });
+
+    test("handles missing description", () => {
+      const issue: LinearIssue = {
+        id: "issue_124",
+        identifier: "ENG-44",
+        title: "Fix bug",
+        state: {
+          id: "state_2",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 4,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const task = toTask(issue, "epic-456");
+
+      expect(task.description).toBeUndefined();
+      expect(task.status).toBe("PENDING");
+      expect(task.priority).toBe("LOW");
+    });
+
+    test("maps Backlog state to PENDING status", () => {
+      const issue: LinearIssue = {
+        id: "issue_125",
+        identifier: "ENG-45",
+        title: "Task in backlog",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 3,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const task = toTask(issue, "epic-789");
+
+      expect(task.status).toBe("PENDING");
+    });
+
+    test("maps In Progress state to IN_PROGRESS status", () => {
+      const issue: LinearIssue = {
+        id: "issue_126",
+        identifier: "ENG-46",
+        title: "Task in progress",
+        state: {
+          id: "state_2",
+          name: "In Progress",
+          type: "started",
+        },
+        priority: 2,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const task = toTask(issue, "epic-789");
+
+      expect(task.status).toBe("IN_PROGRESS");
+    });
+
+    test("maps Done state to COMPLETED status", () => {
+      const issue: LinearIssue = {
+        id: "issue_127",
+        identifier: "ENG-47",
+        title: "Task done",
+        state: {
+          id: "state_3",
+          name: "Done",
+          type: "completed",
+        },
+        priority: 3,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-01T00:00:00Z",
+      };
+
+      const task = toTask(issue, "epic-789");
+
+      expect(task.status).toBe("COMPLETED");
+    });
+  });
+
+  describe("Priority Mapping", () => {
+    describe("toLinearPriority", () => {
+      test("maps LOW to 4 (no priority)", () => {
+        expect(toLinearPriority("LOW")).toBe(4);
+      });
+
+      test("maps MEDIUM to 3", () => {
+        expect(toLinearPriority("MEDIUM")).toBe(3);
+      });
+
+      test("maps HIGH to 2", () => {
+        expect(toLinearPriority("HIGH")).toBe(2);
+      });
+    });
+
+    describe("toFluxPriority", () => {
+      test("maps 4 to LOW", () => {
+        expect(toFluxPriority(4)).toBe("LOW");
+      });
+
+      test("maps 3 to MEDIUM", () => {
+        expect(toFluxPriority(3)).toBe("MEDIUM");
+      });
+
+      test("maps 2 to HIGH", () => {
+        expect(toFluxPriority(2)).toBe("HIGH");
+      });
+
+      test("maps 1 (urgent) to HIGH", () => {
+        expect(toFluxPriority(1)).toBe("HIGH");
+      });
+
+      test("defaults to LOW for unknown priority", () => {
+        expect(toFluxPriority(0)).toBe("LOW");
+        expect(toFluxPriority(5)).toBe("LOW");
+      });
+    });
+  });
+
+  describe("Status Mapping", () => {
+    describe("toLinearTaskState", () => {
+      test("maps PENDING to Todo", () => {
+        expect(toLinearTaskState("PENDING")).toBe("Todo");
+      });
+
+      test("maps IN_PROGRESS to In Progress", () => {
+        expect(toLinearTaskState("IN_PROGRESS")).toBe("In Progress");
+      });
+
+      test("maps COMPLETED to Done", () => {
+        expect(toLinearTaskState("COMPLETED")).toBe("Done");
+      });
+    });
+
+    describe("toFluxTaskStatus", () => {
+      test("maps Backlog to PENDING", () => {
+        expect(toFluxTaskStatus("Backlog")).toBe("PENDING");
+      });
+
+      test("maps In Progress to IN_PROGRESS", () => {
+        expect(toFluxTaskStatus("In Progress")).toBe("IN_PROGRESS");
+      });
+
+      test("maps Done to COMPLETED", () => {
+        expect(toFluxTaskStatus("Done")).toBe("COMPLETED");
+      });
+
+      test("defaults to PENDING for unknown state", () => {
+        expect(toFluxTaskStatus("Unknown")).toBe("PENDING");
+      });
+    });
+  });
+});