@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,243 @@
+import { describe, expect, test } from "bun:test";
+import {
+  extractTagFromLabels,
+  FLUX_MILESTONE_LABEL_PREFIX,
+  getMilestoneLabel,
+  type LINEAR_EPIC_STATUS_MAP,
+  type LINEAR_PRD_STATUS_MAP,
+  type LINEAR_PRIORITY_MAP,
+  type LINEAR_TASK_STATUS_MAP,
+  type LinearConfig,
+  type LinearIssue,
+  type LinearProject,
+  type LinearWorkflowState,
+} from "../linear/types.js";
+
+describe("Linear Types", () => {
+  describe("LinearConfig", () => {
+    test("has required fields", () => {
+      const config: LinearConfig = {
+        apiKey: "lin_api_test123",
+        teamId: "TEAM-123",
+        projectId: "proj_123",
+        defaultLabels: {
+          prd: "prd",
+          epic: "epic",
+          task: "task",
+        },
+      };
+
+      expect(config.apiKey).toBe("lin_api_test123");
+      expect(config.teamId).toBe("TEAM-123");
+      expect(config.projectId).toBe("proj_123");
+      expect(config.defaultLabels.prd).toBe("prd");
+      expect(config.defaultLabels.epic).toBe("epic");
+      expect(config.defaultLabels.task).toBe("task");
+    });
+  });
+
+  describe("LinearProject", () => {
+    test("has required Linear project fields", () => {
+      const project: LinearProject = {
+        id: "proj_abc123",
+        name: "Test Project",
+        description: "A test project",
+        state: "started",
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      expect(project.id).toBe("proj_abc123");
+      expect(project.name).toBe("Test Project");
+      expect(project.state).toBe("started");
+    });
+
+    test("allows optional description", () => {
+      const project: LinearProject = {
+        id: "proj_abc123",
+        name: "Test Project",
+        state: "started",
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      expect(project.description).toBeUndefined();
+    });
+  });
+
+  describe("LinearIssue", () => {
+    test("has required Linear issue fields", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-42",
+        title: "Test Issue",
+        description: "Issue description",
+        state: {
+          id: "state_1",
+          name: "In Progress",
+          type: "started",
+        },
+        priority: 2,
+        projectId: "proj_abc123",
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+      };
+
+      expect(issue.id).toBe("issue_123");
+      expect(issue.identifier).toBe("ENG-42");
+      expect(issue.state.name).toBe("In Progress");
+      expect(issue.priority).toBe(2);
+    });
+
+    test("allows optional parent and labels", () => {
+      const issue: LinearIssue = {
+        id: "issue_123",
+        identifier: "ENG-43",
+        title: "Child Task",
+        state: {
+          id: "state_1",
+          name: "Backlog",
+          type: "backlog",
+        },
+        priority: 3,
+        createdAt: "2024-01-01T00:00:00Z",
+        updatedAt: "2024-01-02T00:00:00Z",
+        parentId: "issue_122",
+        labels: [{ id: "label_1", name: "task" }],
+      };
+
+      expect(issue.parentId).toBe("issue_122");
+      expect(issue.labels).toHaveLength(1);
+      expect(issue.labels?.[0].name).toBe("task");
+    });
+  });
+
+  describe("LinearWorkflowState", () => {
+    test("has required workflow state fields", () => {
+      const state: LinearWorkflowState = {
+        id: "state_1",
+        name: "In Progress",
+        type: "started",
+      };
+
+      expect(state.id).toBe("state_1");
+      expect(state.name).toBe("In Progress");
+      expect(state.type).toBe("started");
+    });
+  });
+
+  describe("Status Mapping Constants", () => {
+    test("LINEAR_PRD_STATUS_MAP maps all PRD statuses", () => {
+      const map: typeof LINEAR_PRD_STATUS_MAP = {
+        DRAFT: "backlog",
+        PENDING_REVIEW: "planned",
+        REVIEWED: "planned",
+        APPROVED: "started",
+        BREAKDOWN_READY: "started",
+        COMPLETED: "completed",
+        ARCHIVED: "canceled",
+      };
+
+      expect(map.DRAFT).toBe("backlog");
+      expect(map.PENDING_REVIEW).toBe("planned");
+      expect(map.REVIEWED).toBe("planned");
+      expect(map.APPROVED).toBe("started");
+      expect(map.BREAKDOWN_READY).toBe("started");
+      expect(map.COMPLETED).toBe("completed");
+      expect(map.ARCHIVED).toBe("canceled");
+    });
+
+    test("LINEAR_EPIC_STATUS_MAP maps epic statuses", () => {
+      const map: typeof LINEAR_EPIC_STATUS_MAP = {
+        PENDING: "Todo",
+        IN_PROGRESS: "In Progress",
+        COMPLETED: "Done",
+      };
+
+      expect(map.PENDING).toBe("Todo");
+      expect(map.IN_PROGRESS).toBe("In Progress");
+      expect(map.COMPLETED).toBe("Done");
+    });
+
+    test("LINEAR_TASK_STATUS_MAP maps task statuses", () => {
+      const map: typeof LINEAR_TASK_STATUS_MAP = {
+        PENDING: "Todo",
+        IN_PROGRESS: "In Progress",
+        COMPLETED: "Done",
+      };
+
+      expect(map.PENDING).toBe("Todo");
+      expect(map.IN_PROGRESS).toBe("In Progress");
+      expect(map.COMPLETED).toBe("Done");
+    });
+
+    test("LINEAR_PRIORITY_MAP maps priorities", () => {
+      const map: typeof LINEAR_PRIORITY_MAP = {
+        LOW: 4,
+        MEDIUM: 3,
+        HIGH: 2,
+      };
+
+      expect(map.LOW).toBe(4);
+      expect(map.MEDIUM).toBe(3);
+      expect(map.HIGH).toBe(2);
+    });
+  });
+
+  describe("Milestone Label Helpers", () => {
+    test("FLUX_MILESTONE_LABEL_PREFIX is correct", () => {
+      expect(FLUX_MILESTONE_LABEL_PREFIX).toBe("flux:milestone:");
+    });
+
+    describe("getMilestoneLabel", () => {
+      test("creates label from tag", () => {
+        expect(getMilestoneLabel("mvp")).toBe("flux:milestone:mvp");
+        expect(getMilestoneLabel("q1-release")).toBe(
+          "flux:milestone:q1-release",
+        );
+        expect(getMilestoneLabel("phase-1")).toBe("flux:milestone:phase-1");
+      });
+
+      test("handles empty string", () => {
+        expect(getMilestoneLabel("")).toBe("flux:milestone:");
+      });
+
+      test("handles special characters in tag", () => {
+        expect(getMilestoneLabel("v2.0.0")).toBe("flux:milestone:v2.0.0");
+        expect(getMilestoneLabel("release_2024")).toBe(
+          "flux:milestone:release_2024",
+        );
+      });
+    });
+
+    describe("extractTagFromLabels", () => {
+      test("extracts tag from milestone label", () => {
+        expect(extractTagFromLabels(["prd", "flux:milestone:mvp"])).toBe("mvp");
+        expect(extractTagFromLabels(["flux:milestone:q1-release", "prd"])).toBe(
+          "q1-release",
+        );
+      });
+
+      test("returns undefined when no milestone label exists", () => {
+        expect(extractTagFromLabels(["prd", "epic"])).toBeUndefined();
+        expect(extractTagFromLabels([])).toBeUndefined();
+      });
+
+      test("returns first milestone label if multiple exist", () => {
+        expect(
+          extractTagFromLabels([
+            "prd",
+            "flux:milestone:first",
+            "flux:milestone:second",
+          ]),
+        ).toBe("first");
+      });
+
+      test("handles labels similar to but not matching prefix", () => {
+        expect(extractTagFromLabels(["flux:status:reviewed"])).toBeUndefined();
+        expect(extractTagFromLabels(["flux-milestone-mvp"])).toBeUndefined();
+        expect(extractTagFromLabels(["milestone:mvp"])).toBeUndefined();
+      });
+    });
+  });
+});

package/src/server/adapters/__tests__/status-ops.test.ts

@@ -0,0 +1,441 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type { HydratedIssue, LinearAdapter } from "../linear/adapter.js";
+import type { LinearConfig } from "../linear/types.js";
+
+/**
+ * Helper to create a mock HydratedIssue
+ */
+function createMockIssue(
+  overrides: Partial<HydratedIssue> = {},
+): HydratedIssue {
+  return {
+    id: "issue_abc123",
+    identifier: "ENG-42",
+    title: "Test Issue",
+    description: "Test description",
+    stateName: "Backlog",
+    stateType: "backlog",
+    labels: ["prd"],
+    parentIdentifier: undefined,
+    priority: 3,
+    createdAt: new Date("2024-01-01T00:00:00Z"),
+    updatedAt: new Date("2024-01-01T00:00:00Z"),
+    _raw: {},
+    ...overrides,
+  };
+}
+
+describe("LinearAdapter - Status Update and Delete Operations", () => {
+  const mockConfig: LinearConfig = {
+    apiKey: "lin_api_test123",
+    teamId: "TEAM-123",
+    projectId: "proj_container",
+    defaultLabels: {
+      prd: "prd",
+      epic: "epic",
+      task: "task",
+    },
+  };
+
+  let adapter: LinearAdapter;
+
+  beforeEach(async () => {
+    const { LinearAdapter: LA } = await import("../linear/adapter.js");
+    adapter = new LA(mockConfig);
+  });
+
+  describe("updateStatus - PRD", () => {
+    test("updates PRD status to APPROVED (Linear: In Progress)", async () => {
+      const mockUpdate = mock(async () => ({}));
+      const mockIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        stateName: "Backlog",
+        labels: ["prd"],
+        _raw: { update: mockUpdate },
+      });
+
+      const mockUpdatedIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        title: "Test PRD",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["prd"],
+        _raw: { update: mockUpdate },
+      });
+
+      // fetchIssue: 1st call returns original, subsequent calls return updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).getStateId = mock(async () => "state_progress");
+      (adapter as any).getLabelId = mock(
+        async (name: string) => `label_${name}`,
+      );
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.updatePrd("ENG-1", {
+        status: "APPROVED",
+      });
+
+      expect(result.status).toBe("APPROVED");
+      // Verify stateId is set in first update call
+      expect(mockUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({ stateId: "state_progress" }),
+      );
+    });
+
+    test("updates PRD status to COMPLETED (Linear: Done)", async () => {
+      const mockUpdate = mock(async () => ({}));
+      const mockIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        stateName: "In Progress",
+        labels: ["prd"],
+        _raw: { update: mockUpdate },
+      });
+
+      const mockUpdatedIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        stateName: "Done",
+        stateType: "completed",
+        labels: ["prd"],
+        _raw: { update: mockUpdate },
+      });
+
+      // fetchIssue: 1st call returns original, subsequent calls return updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).getStateId = mock(async () => "state_done");
+      (adapter as any).getLabelId = mock(
+        async (name: string) => `label_${name}`,
+      );
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.updatePrd("ENG-1", {
+        status: "COMPLETED",
+      });
+
+      expect(result.status).toBe("COMPLETED");
+      // Verify stateId is set in first update call
+      expect(mockUpdate).toHaveBeenCalledWith(
+        expect.objectContaining({ stateId: "state_done" }),
+      );
+    });
+  });
+
+  describe("updateStatus - Epic", () => {
+    test("updates Epic status to IN_PROGRESS (Linear: In Progress)", async () => {
+      const mockUpdate = mock(async () => ({}));
+      const mockIssue = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        stateName: "Backlog",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+        _raw: { update: mockUpdate },
+      });
+
+      const mockUpdatedIssue = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        stateName: "In Progress",
+        stateType: "started",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).getStateId = mock(async () => "state_progress");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.updateEpic("ENG-42", {
+        status: "IN_PROGRESS",
+      });
+
+      expect(result.status).toBe("IN_PROGRESS");
+      expect(mockUpdate).toHaveBeenCalledWith({
+        stateId: "state_progress",
+      });
+    });
+
+    test("updates Epic status to COMPLETED (Linear: Done)", async () => {
+      const mockUpdate = mock(async () => ({}));
+      const mockIssue = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        stateName: "In Progress",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+        _raw: { update: mockUpdate },
+      });
+
+      const mockUpdatedIssue = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        stateName: "Done",
+        stateType: "completed",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).getStateId = mock(async () => "state_done");
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.updateEpic("ENG-42", {
+        status: "COMPLETED",
+      });
+
+      expect(result.status).toBe("COMPLETED");
+      expect(mockUpdate).toHaveBeenCalledWith({ stateId: "state_done" });
+    });
+
+    test("throws error when target workflow state not found", async () => {
+      const mockIssue = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        parentIdentifier: "ENG-1",
+        _raw: { update: mock(async () => ({})) },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockIssue);
+      (adapter as any).getStateId = mock(async () => {
+        throw new Error("Workflow state 'In Progress' not found");
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      await expect(
+        adapter.updateEpic("ENG-42", { status: "IN_PROGRESS" }),
+      ).rejects.toThrow("Workflow state 'In Progress' not found");
+    });
+  });
+
+  describe("updateStatus - Task", () => {
+    test("updates Task status to COMPLETED (Linear: Done)", async () => {
+      const mockUpdate = mock(async () => ({}));
+      const mockIssue = createMockIssue({
+        id: "issue_456",
+        identifier: "ENG-43",
+        stateName: "In Progress",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { update: mockUpdate },
+      });
+
+      const mockUpdatedIssue = createMockIssue({
+        id: "issue_456",
+        identifier: "ENG-43",
+        stateName: "Done",
+        stateType: "completed",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+      });
+
+      // fetchIssue returns original first, then updated
+      let fetchCount = 0;
+      (adapter as any).fetchIssue = mock(async () => {
+        fetchCount++;
+        return fetchCount === 1 ? mockIssue : mockUpdatedIssue;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+        client: {
+          team: mock(async () => ({
+            states: mock(async () => ({
+              nodes: [
+                { id: "state_backlog", name: "Backlog" },
+                { id: "state_progress", name: "In Progress" },
+                { id: "state_done", name: "Done" },
+              ],
+            })),
+          })),
+        },
+      };
+
+      const result = await adapter.updateTask("ENG-43", {
+        status: "COMPLETED",
+      });
+
+      expect(result.status).toBe("COMPLETED");
+      expect(mockUpdate).toHaveBeenCalledWith({ stateId: "state_done" });
+    });
+  });
+
+  describe("deletePrd", () => {
+    test("archives PRD and returns cascade count", async () => {
+      const mockTaskArchive = mock(async () => ({ success: true }));
+      const mockEpicArchive = mock(async () => ({ success: true }));
+      const mockPrdArchive = mock(async () => ({ success: true }));
+
+      const mockEpic1 = createMockIssue({
+        id: "issue_epic_1",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({
+            nodes: [
+              { id: "task_1", archive: mockTaskArchive },
+              { id: "task_2", archive: mockTaskArchive },
+            ],
+          })),
+        },
+      });
+
+      const mockEpic2 = createMockIssue({
+        id: "issue_epic_2",
+        identifier: "ENG-43",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      const mockPrdIssue = createMockIssue({
+        id: "issue_prd_123",
+        identifier: "ENG-1",
+        labels: ["prd"],
+        _raw: {
+          archive: mockPrdArchive,
+          children: mock(async () => ({
+            nodes: [mockEpic1._raw, mockEpic2._raw],
+          })),
+        },
+      });
+
+      let hydrateCallCount = 0;
+      (adapter as any).fetchIssue = mock(async () => mockPrdIssue);
+      (adapter as any).hydrateIssue = mock(async () => {
+        hydrateCallCount++;
+        if (hydrateCallCount === 1) return mockEpic1;
+        return mockEpic2;
+      });
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deletePrd("ENG-1");
+
+      expect(result.deleted).toBe("ENG-1");
+      expect(result.cascade.epics).toBe(2);
+      expect(result.cascade.tasks).toBe(2);
+      expect(mockPrdArchive).toHaveBeenCalled();
+    });
+  });
+
+  describe("deleteEpic", () => {
+    test("archives Epic and its tasks, returns cascade count", async () => {
+      const mockTaskArchive = mock(async () => ({ success: true }));
+      const mockEpicArchive = mock(async () => ({ success: true }));
+
+      const mockEpic = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({
+            nodes: [
+              { id: "task_1", archive: mockTaskArchive },
+              { id: "task_2", archive: mockTaskArchive },
+            ],
+          })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteEpic("ENG-42");
+
+      expect(result.deleted).toBe("ENG-42");
+      expect(result.cascade.tasks).toBe(2);
+      expect(result.cascade.epics).toBe(0);
+      expect(mockEpicArchive).toHaveBeenCalled();
+    });
+
+    test("archives Epic with no tasks", async () => {
+      const mockEpicArchive = mock(async () => ({ success: true }));
+
+      const mockEpic = createMockIssue({
+        id: "issue_123",
+        identifier: "ENG-42",
+        labels: ["epic"],
+        _raw: {
+          archive: mockEpicArchive,
+          children: mock(async () => ({ nodes: [] })),
+        },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockEpic);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteEpic("ENG-42");
+
+      expect(result.deleted).toBe("ENG-42");
+      expect(result.cascade.tasks).toBe(0);
+      expect(mockEpicArchive).toHaveBeenCalled();
+    });
+  });
+
+  describe("deleteTask", () => {
+    test("archives Task", async () => {
+      const mockTaskArchive = mock(async () => ({ success: true }));
+
+      const mockTask = createMockIssue({
+        id: "issue_456",
+        identifier: "ENG-43",
+        labels: ["task"],
+        parentIdentifier: "ENG-42",
+        _raw: { archive: mockTaskArchive },
+      });
+
+      (adapter as any).fetchIssue = mock(async () => mockTask);
+      (adapter as any).client = {
+        execute: mock(async (fn: () => Promise<any>) => fn()),
+      };
+
+      const result = await adapter.deleteTask("ENG-43");
+
+      expect(result.deleted).toBe("ENG-43");
+      expect(result.cascade.tasks).toBe(0);
+      expect(result.cascade.epics).toBe(0);
+      expect(mockTaskArchive).toHaveBeenCalled();
+    });
+  });
+});