@cliangdev/flux-plugin 0.3.1-dev.bdbaeae → 0.3.1

package/src/server/adapters/github/__tests__/epic-task-crud.test.ts

@@ -1,1072 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-
-const TEST_DIR = `${realpathSync(tmpdir())}/flux-epic-task-crud-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-process.env.FLUX_PROJECT_ROOT = TEST_DIR;
-
-let mockIssuesCreate: any = null;
-let mockIssuesUpdate: any = null;
-let mockIssuesGet: Record<number, any> = {};
-let mockIssuesList: any[] = [];
-let mockSubIssues: Record<number, any[]> = {};
-let mockGetContent: any = null;
-let mockGraphqlFn: (
-  query: string,
-  variables?: Record<string, unknown>,
-) => Promise<unknown> = async () => ({});
-let _lastCreateParams: any = null;
-let _lastUpdateParams: any = null;
-let lastUpdateByNumberParams: Record<number, any> = {};
-let lastPutParams: any = null;
-let lastAddSubIssueParams: any[] = [];
-let issueNodeIdCounter = 0;
-
-mock.module("@octokit/rest", () => ({
-  Octokit: class MockOctokit {
-    repos = {
-      getContent: async (_params: any) => {
-        if (mockGetContent === null) {
-          const err: any = new Error("Not Found");
-          err.status = 404;
-          throw err;
-        }
-        return mockGetContent;
-      },
-      createOrUpdateFileContents: async (params: any) => {
-        lastPutParams = params;
-        return { data: { content: { sha: "new-sha" } } };
-      },
-    };
-
-    issues = {
-      create: async (params: any) => {
-        _lastCreateParams = params;
-        return { data: mockIssuesCreate };
-      },
-      update: async (params: any) => {
-        const num = params.issue_number;
-        lastUpdateByNumberParams[num] = params;
-        _lastUpdateParams = params;
-        return { data: mockIssuesUpdate ?? mockIssuesCreate };
-      },
-      get: async (params: any) => {
-        const num = params.issue_number;
-        if (mockIssuesGet[num]) return { data: mockIssuesGet[num] };
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      },
-      listForRepo: async (_params: any) => {
-        return { data: mockIssuesList };
-      },
-    };
-  },
-}));
-
-mock.module("@octokit/graphql", () => ({
-  graphql: {
-    defaults: (_opts: any) => {
-      return async (query: string, variables?: Record<string, unknown>) => {
-        return mockGraphqlFn(query, variables);
-      };
-    },
-  },
-}));
-
-function makeIssue(
-  overrides: Partial<{
-    number: number;
-    id: number;
-    title: string;
-    body: string;
-    labels: string[];
-    state: "open" | "closed";
-    created_at: string;
-    updated_at: string;
-    node_id: string;
-  }> = {},
-) {
-  issueNodeIdCounter++;
-  const number = overrides.number ?? issueNodeIdCounter;
-  return {
-    number,
-    id: overrides.id ?? number * 1000,
-    title: overrides.title ?? "Test Issue",
-    body: overrides.body ?? "",
-    labels: (overrides.labels ?? []).map((name) => ({ name })),
-    state: overrides.state ?? "open",
-    created_at: overrides.created_at ?? "2026-01-01T00:00:00Z",
-    updated_at: overrides.updated_at ?? "2026-01-01T00:00:00Z",
-    node_id: overrides.node_id ?? `MDU6SXNzdWU${number}`,
-  };
-}
-
-function makeAdapter() {
-  const { GitHubAdapter } = require("../adapter.js");
-  const adapter = new GitHubAdapter({
-    token: "ghp_test",
-    owner: "test-owner",
-    repo: "test-repo",
-    projectId: "PVT_kwDO123",
-    refPrefix: "FP",
-  });
-
-  (adapter as any).client.rest.issues = {
-    create: async (params: any) => {
-      _lastCreateParams = params;
-      return { data: mockIssuesCreate };
-    },
-    update: async (params: any) => {
-      const num = params.issue_number;
-      lastUpdateByNumberParams[num] = params;
-      _lastUpdateParams = params;
-      if (mockIssuesUpdate !== null) {
-        return { data: mockIssuesUpdate };
-      }
-      return { data: mockIssuesCreate };
-    },
-    get: async (params: any) => {
-      const num = params.issue_number;
-      if (mockIssuesGet[num]) return { data: mockIssuesGet[num] };
-      const err: any = new Error("Not Found");
-      err.status = 404;
-      throw err;
-    },
-    listForRepo: async (_params: any) => {
-      return { data: mockIssuesList };
-    },
-    listSubIssues: async (params: any) => {
-      const issueNum = params.issue_number;
-      return { data: mockSubIssues[issueNum] ?? [] };
-    },
-    addSubIssue: async (params: any) => {
-      lastAddSubIssueParams.push(params);
-      return { data: {} };
-    },
-  };
-
-  (adapter as any).client.rest.repos = {
-    getContent: async (_params: any) => {
-      if (mockGetContent === null) {
-        const err: any = new Error("Not Found");
-        err.status = 404;
-        throw err;
-      }
-      return mockGetContent;
-    },
-    createOrUpdateFileContents: async (params: any) => {
-      lastPutParams = params;
-      return { data: { content: { sha: "new-sha" } } };
-    },
-  };
-
-  (adapter as any).client.rest.request = async (url: string, params: any) => {
-    if (url.includes("sub_issues") && url.startsWith("GET")) {
-      return { data: mockSubIssues[params.issue_number] ?? [] };
-    }
-    if (url.includes("sub_issues") && url.startsWith("POST")) {
-      lastAddSubIssueParams.push(params);
-      return { data: {} };
-    }
-    throw new Error(`Unmocked request: ${url}`);
-  };
-
-  return adapter;
-}
-
-describe("epic status mappers", () => {
-  test("epicStatusToLabel returns null for PENDING", async () => {
-    const { epicStatusToLabel } = await import("../mappers/epic.js");
-    expect(epicStatusToLabel("PENDING")).toBeNull();
-  });
-
-  test("epicStatusToLabel returns status:in-progress for IN_PROGRESS", async () => {
-    const { epicStatusToLabel } = await import("../mappers/epic.js");
-    expect(epicStatusToLabel("IN_PROGRESS")).toBe("status:in-progress");
-  });
-
-  test("epicStatusToLabel returns null for COMPLETED", async () => {
-    const { epicStatusToLabel } = await import("../mappers/epic.js");
-    expect(epicStatusToLabel("COMPLETED")).toBeNull();
-  });
-
-  test("labelToEpicStatus returns COMPLETED for closed issue", async () => {
-    const { labelToEpicStatus } = await import("../mappers/epic.js");
-    expect(labelToEpicStatus(["flux:epic"], true)).toBe("COMPLETED");
-    expect(labelToEpicStatus(["flux:epic", "status:in-progress"], true)).toBe(
-      "COMPLETED",
-    );
-  });
-
-  test("labelToEpicStatus returns IN_PROGRESS for open issue with status:in-progress", async () => {
-    const { labelToEpicStatus } = await import("../mappers/epic.js");
-    expect(labelToEpicStatus(["flux:epic", "status:in-progress"], false)).toBe(
-      "IN_PROGRESS",
-    );
-  });
-
-  test("labelToEpicStatus returns PENDING for open issue with no status label", async () => {
-    const { labelToEpicStatus } = await import("../mappers/epic.js");
-    expect(labelToEpicStatus(["flux:epic"], false)).toBe("PENDING");
-  });
-
-  test("all EpicStatus values round-trip through label encoding", async () => {
-    const { labelToEpicStatus } = await import("../mappers/epic.js");
-    expect(labelToEpicStatus([], false)).toBe("PENDING");
-    expect(labelToEpicStatus(["status:in-progress"], false)).toBe(
-      "IN_PROGRESS",
-    );
-    expect(labelToEpicStatus([], true)).toBe("COMPLETED");
-  });
-});
-
-describe("task status and priority mappers", () => {
-  test("taskStatusToLabel returns null for PENDING", async () => {
-    const { taskStatusToLabel } = await import("../mappers/task.js");
-    expect(taskStatusToLabel("PENDING")).toBeNull();
-  });
-
-  test("taskStatusToLabel returns status:in-progress for IN_PROGRESS", async () => {
-    const { taskStatusToLabel } = await import("../mappers/task.js");
-    expect(taskStatusToLabel("IN_PROGRESS")).toBe("status:in-progress");
-  });
-
-  test("taskStatusToLabel returns null for COMPLETED", async () => {
-    const { taskStatusToLabel } = await import("../mappers/task.js");
-    expect(taskStatusToLabel("COMPLETED")).toBeNull();
-  });
-
-  test("labelToTaskStatus returns COMPLETED for closed issue", async () => {
-    const { labelToTaskStatus } = await import("../mappers/task.js");
-    expect(labelToTaskStatus(["flux:task"], true)).toBe("COMPLETED");
-  });
-
-  test("labelToTaskStatus returns IN_PROGRESS for open issue with status:in-progress", async () => {
-    const { labelToTaskStatus } = await import("../mappers/task.js");
-    expect(labelToTaskStatus(["flux:task", "status:in-progress"], false)).toBe(
-      "IN_PROGRESS",
-    );
-  });
-
-  test("labelToTaskStatus returns PENDING for open issue with no status label", async () => {
-    const { labelToTaskStatus } = await import("../mappers/task.js");
-    expect(labelToTaskStatus(["flux:task"], false)).toBe("PENDING");
-  });
-
-  test("all TaskStatus values round-trip", async () => {
-    const { labelToTaskStatus } = await import("../mappers/task.js");
-    expect(labelToTaskStatus([], false)).toBe("PENDING");
-    expect(labelToTaskStatus(["status:in-progress"], false)).toBe(
-      "IN_PROGRESS",
-    );
-    expect(labelToTaskStatus([], true)).toBe("COMPLETED");
-  });
-
-  test("priorityToLabel returns correct labels", async () => {
-    const { priorityToLabel } = await import("../mappers/task.js");
-    expect(priorityToLabel("LOW")).toBe("priority:low");
-    expect(priorityToLabel("MEDIUM")).toBe("priority:medium");
-    expect(priorityToLabel("HIGH")).toBe("priority:high");
-  });
-
-  test("labelToPriority returns HIGH when priority:high present", async () => {
-    const { labelToPriority } = await import("../mappers/task.js");
-    expect(labelToPriority(["flux:task", "priority:high"])).toBe("HIGH");
-  });
-
-  test("labelToPriority returns LOW when priority:low present", async () => {
-    const { labelToPriority } = await import("../mappers/task.js");
-    expect(labelToPriority(["flux:task", "priority:low"])).toBe("LOW");
-  });
-
-  test("labelToPriority defaults to MEDIUM", async () => {
-    const { labelToPriority } = await import("../mappers/task.js");
-    expect(labelToPriority(["flux:task"])).toBe("MEDIUM");
-    expect(labelToPriority(["flux:task", "priority:medium"])).toBe("MEDIUM");
-  });
-
-  test("all Priority values round-trip through label encoding", async () => {
-    const { priorityToLabel, labelToPriority } = await import(
-      "../mappers/task.js"
-    );
-    for (const priority of ["LOW", "MEDIUM", "HIGH"] as const) {
-      const label = priorityToLabel(priority);
-      expect(labelToPriority([label])).toBe(priority);
-    }
-  });
-});
-
-describe("GitHubAdapter Epic CRUD", () => {
-  beforeEach(() => {
-    mockIssuesCreate = null;
-    mockIssuesUpdate = null;
-    mockIssuesGet = {};
-    mockIssuesList = [];
-    mockSubIssues = {};
-    mockGetContent = null;
-    _lastCreateParams = null;
-    _lastUpdateParams = null;
-    lastUpdateByNumberParams = {};
-    lastPutParams = null;
-    lastAddSubIssueParams = [];
-    issueNodeIdCounter = 0;
-    mockGraphqlFn = async () => ({
-      addProjectV2ItemById: { item: { id: "PVTI_123" } },
-    });
-  });
-
-  afterEach(() => {});
-
-  describe("createEpic", () => {
-    test("returns Epic with correct prdId", async () => {
-      const prdIssue = makeIssue({
-        number: 1,
-        labels: ["flux:prd", "status:draft"],
-        body: '<!-- flux-meta\n{"ref":"FP-P1"}\n-->',
-      });
-
-      const epicIssue = makeIssue({
-        number: 10,
-        title: "My Epic",
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E10","prd_ref":"FP-P1","dependencies":[]}\n-->',
-        node_id: "NODE_EPIC_10",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-P1": 1 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = epicIssue;
-      mockIssuesUpdate = epicIssue;
-      mockIssuesGet[1] = prdIssue;
-      mockIssuesGet[10] = epicIssue;
-
-      const adapter = makeAdapter();
-      const epic = await adapter.createEpic({
-        prdRef: "FP-P1",
-        title: "My Epic",
-      });
-
-      expect(epic.ref).toBe("FP-E10");
-      expect(epic.prdId).toBe("FP-P1");
-      expect(epic.title).toBe("My Epic");
-      expect(epic.status).toBe("PENDING");
-    });
-
-    test("created epic issue is a sub-issue of the PRD issue", async () => {
-      const prdIssue = makeIssue({
-        number: 2,
-        labels: ["flux:prd", "status:draft"],
-        body: '<!-- flux-meta\n{"ref":"FP-P2"}\n-->',
-      });
-
-      const epicIssue = makeIssue({
-        number: 20,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E20","prd_ref":"FP-P2","dependencies":[]}\n-->',
-        node_id: "NODE_20",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-P2": 2 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = epicIssue;
-      mockIssuesUpdate = epicIssue;
-      mockIssuesGet[2] = prdIssue;
-      mockIssuesGet[20] = epicIssue;
-
-      const adapter = makeAdapter();
-      await adapter.createEpic({ prdRef: "FP-P2", title: "Epic for PRD 2" });
-
-      expect(lastAddSubIssueParams.length).toBeGreaterThan(0);
-      const subIssueCall = lastAddSubIssueParams[0];
-      expect(subIssueCall.issue_number).toBe(2);
-      expect(subIssueCall.sub_issue_id).toBe(20000);
-    });
-
-    test("flux-meta contains ref and prd_ref", async () => {
-      const prdIssue = makeIssue({
-        number: 3,
-        labels: ["flux:prd"],
-        body: '<!-- flux-meta\n{"ref":"FP-P3"}\n-->',
-      });
-
-      const epicIssue = makeIssue({
-        number: 30,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E30","prd_ref":"FP-P3","dependencies":[]}\n-->',
-        node_id: "NODE_30",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-P3": 3 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = epicIssue;
-      mockIssuesUpdate = epicIssue;
-      mockIssuesGet[3] = prdIssue;
-      mockIssuesGet[30] = epicIssue;
-
-      const adapter = makeAdapter();
-      await adapter.createEpic({ prdRef: "FP-P3", title: "Epic Meta Check" });
-
-      const updateCall = lastUpdateByNumberParams[30];
-      expect(updateCall).toBeDefined();
-      expect(updateCall.body).toContain('"ref":"FP-E30"');
-      expect(updateCall.body).toContain('"prd_ref":"FP-P3"');
-    });
-  });
-
-  describe("updateEpic", () => {
-    test("updateEpic status COMPLETED closes the issue", async () => {
-      const epicIssue = makeIssue({
-        number: 50,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E50","prd_ref":"FP-P5"}\n-->',
-      });
-
-      const closedEpicIssue = {
-        ...epicIssue,
-        state: "closed" as const,
-      };
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E50": 50 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesGet[50] = epicIssue;
-      mockIssuesUpdate = closedEpicIssue;
-
-      const adapter = makeAdapter();
-      const epic = await adapter.updateEpic("FP-E50", { status: "COMPLETED" });
-
-      expect(lastUpdateByNumberParams[50]?.state).toBe("closed");
-      expect(epic.status).toBe("COMPLETED");
-    });
-
-    test("updateEpic on unknown ref throws descriptive error", async () => {
-      mockGetContent = null;
-      mockIssuesList = [];
-
-      const adapter = makeAdapter();
-
-      await expect(
-        adapter.updateEpic("FP-E999", { title: "New Title" }),
-      ).rejects.toThrow("FP-E999");
-    });
-
-    test("updateEpic IN_PROGRESS adds status:in-progress label", async () => {
-      const epicIssue = makeIssue({
-        number: 55,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E55","prd_ref":"FP-P5"}\n-->',
-      });
-
-      const updatedEpicIssue = makeIssue({
-        number: 55,
-        labels: ["flux:epic", "status:in-progress"],
-        body: '<!-- flux-meta\n{"ref":"FP-E55","prd_ref":"FP-P5"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E55": 55 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesGet[55] = epicIssue;
-      mockIssuesUpdate = updatedEpicIssue;
-
-      const adapter = makeAdapter();
-      await adapter.updateEpic("FP-E55", { status: "IN_PROGRESS" });
-
-      const updatedLabels: string[] =
-        lastUpdateByNumberParams[55]?.labels ?? [];
-      expect(updatedLabels).toContain("status:in-progress");
-    });
-  });
-
-  describe("getEpic", () => {
-    test("returns null for unknown ref", async () => {
-      mockGetContent = null;
-      mockIssuesList = [];
-
-      const adapter = makeAdapter();
-      const result = await adapter.getEpic("FP-E999");
-
-      expect(result).toBeNull();
-    });
-
-    test("returns correct Epic with status parsed from labels", async () => {
-      const epicIssue = makeIssue({
-        number: 60,
-        title: "My Epic",
-        labels: ["flux:epic", "status:in-progress"],
-        body: '<!-- flux-meta\n{"ref":"FP-E60","prd_ref":"FP-P6"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E60": 60 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-      mockIssuesGet[60] = epicIssue;
-
-      const adapter = makeAdapter();
-      const epic = await adapter.getEpic("FP-E60");
-
-      expect(epic).not.toBeNull();
-      expect(epic?.ref).toBe("FP-E60");
-      expect(epic?.status).toBe("IN_PROGRESS");
-      expect(epic?.prdId).toBe("FP-P6");
-      expect(epic?.title).toBe("My Epic");
-    });
-  });
-
-  describe("listEpics", () => {
-    test("listEpics filtered by prd_ref returns only epics belonging to that PRD", async () => {
-      makeIssue({
-        number: 70,
-        labels: ["flux:prd"],
-        body: '<!-- flux-meta\n{"ref":"FP-P7"}\n-->',
-      });
-
-      const epicIssue1 = makeIssue({
-        number: 71,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E71","prd_ref":"FP-P7"}\n-->',
-      });
-
-      const epicIssue2 = makeIssue({
-        number: 72,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E72","prd_ref":"FP-P7"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-P7": 70 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesList = [epicIssue1, epicIssue2];
-
-      const adapter = makeAdapter();
-      const result = await adapter.listEpics({ prdRef: "FP-P7" });
-
-      expect(result.items.length).toBe(2);
-      expect(result.items[0].ref).toBe("FP-E71");
-      expect(result.items[1].ref).toBe("FP-E72");
-    });
-
-    test("listEpics without filter queries by flux:epic label", async () => {
-      const epicIssue = makeIssue({
-        number: 80,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E80","prd_ref":"FP-P8"}\n-->',
-      });
-      mockIssuesList = [epicIssue];
-
-      const adapter = makeAdapter();
-      const result = await adapter.listEpics();
-
-      expect(result.items.length).toBe(1);
-      expect(result.items[0].ref).toBe("FP-E80");
-    });
-  });
-
-  describe("deleteEpic", () => {
-    test("deleteEpic closes epic and all child task issues, returns correct cascade counts", async () => {
-      const epicIssue = makeIssue({
-        number: 90,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E90","prd_ref":"FP-P9"}\n-->',
-      });
-
-      const taskIssue1 = makeIssue({
-        number: 91,
-        labels: ["flux:task"],
-        body: '<!-- flux-meta\n{"ref":"FP-T91","epic_ref":"FP-E90"}\n-->',
-      });
-
-      const taskIssue2 = makeIssue({
-        number: 92,
-        labels: ["flux:task"],
-        body: '<!-- flux-meta\n{"ref":"FP-T92","epic_ref":"FP-E90"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(
-            JSON.stringify({ "FP-E90": 90, "FP-T91": 91, "FP-T92": 92 }),
-          ).toString("base64"),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesList = [taskIssue1, taskIssue2];
-      mockIssuesGet[90] = epicIssue;
-      mockIssuesGet[91] = taskIssue1;
-      mockIssuesGet[92] = taskIssue2;
-
-      const closedIssues: number[] = [];
-      const adapter = makeAdapter();
-      (adapter as any).client.rest.issues.update = async (params: any) => {
-        closedIssues.push(params.issue_number);
-        lastUpdateByNumberParams[params.issue_number] = params;
-        return { data: { ...epicIssue, state: "closed" } };
-      };
-
-      const result = await adapter.deleteEpic("FP-E90");
-
-      expect(result.deleted).toBe("FP-E90");
-      expect(result.cascade.tasks).toBe(2);
-      expect(result.cascade.epics).toBe(0);
-      expect(closedIssues).toContain(90);
-      expect(closedIssues).toContain(91);
-      expect(closedIssues).toContain(92);
-    });
-
-    test("all deleted refs removed from index", async () => {
-      const epicIssue = makeIssue({
-        number: 95,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E95","prd_ref":"FP-P9"}\n-->',
-      });
-
-      const taskIssue = makeIssue({
-        number: 96,
-        labels: ["flux:task"],
-        body: '<!-- flux-meta\n{"ref":"FP-T96","epic_ref":"FP-E95"}\n-->',
-      });
-
-      const indexData = { "FP-E95": 95, "FP-T96": 96 };
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify(indexData)).toString("base64"),
-          encoding: "base64",
-        },
-      };
-
-      mockSubIssues[95] = [taskIssue];
-      mockIssuesGet[95] = epicIssue;
-      mockIssuesGet[96] = taskIssue;
-
-      const adapter = makeAdapter();
-      (adapter as any).client.rest.issues.update = async (_params: any) => ({
-        data: { ...epicIssue, state: "closed" },
-      });
-
-      await adapter.deleteEpic("FP-E95");
-
-      const written = JSON.parse(
-        Buffer.from(lastPutParams.content, "base64").toString("utf-8"),
-      );
-      expect(written["FP-E95"]).toBeUndefined();
-    });
-  });
-});
-
-describe("GitHubAdapter Task CRUD", () => {
-  beforeEach(() => {
-    mockIssuesCreate = null;
-    mockIssuesUpdate = null;
-    mockIssuesGet = {};
-    mockIssuesList = [];
-    mockSubIssues = {};
-    mockGetContent = null;
-    _lastCreateParams = null;
-    _lastUpdateParams = null;
-    lastUpdateByNumberParams = {};
-    lastPutParams = null;
-    lastAddSubIssueParams = [];
-    issueNodeIdCounter = 0;
-    mockGraphqlFn = async () => ({
-      addProjectV2ItemById: { item: { id: "PVTI_123" } },
-    });
-  });
-
-  afterEach(() => {});
-
-  describe("createTask", () => {
-    test("returns Task with correct epicId and priority", async () => {
-      const epicIssue = makeIssue({
-        number: 100,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E100","prd_ref":"FP-P10"}\n-->',
-      });
-
-      const taskIssue = makeIssue({
-        number: 101,
-        title: "My Task",
-        labels: ["flux:task", "priority:high"],
-        body: '<!-- flux-meta\n{"ref":"FP-T101","epic_ref":"FP-E100","prd_ref":"FP-P10","priority":"HIGH","dependencies":[]}\n-->',
-        node_id: "NODE_TASK_101",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E100": 100 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = taskIssue;
-      mockIssuesUpdate = taskIssue;
-      mockIssuesGet[100] = epicIssue;
-      mockIssuesGet[101] = taskIssue;
-
-      const adapter = makeAdapter();
-      const task = await adapter.createTask({
-        epicRef: "FP-E100",
-        title: "My Task",
-        priority: "HIGH",
-      });
-
-      expect(task.ref).toBe("FP-T101");
-      expect(task.epicId).toBe("FP-E100");
-      expect(task.priority).toBe("HIGH");
-      expect(task.title).toBe("My Task");
-    });
-
-    test("created task issue is a sub-issue of the epic issue", async () => {
-      const epicIssue = makeIssue({
-        number: 110,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E110","prd_ref":"FP-P11"}\n-->',
-      });
-
-      const taskIssue = makeIssue({
-        number: 111,
-        labels: ["flux:task", "priority:medium"],
-        body: '<!-- flux-meta\n{"ref":"FP-T111","epic_ref":"FP-E110","prd_ref":"FP-P11","priority":"MEDIUM","dependencies":[]}\n-->',
-        node_id: "NODE_111",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E110": 110 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = taskIssue;
-      mockIssuesUpdate = taskIssue;
-      mockIssuesGet[110] = epicIssue;
-      mockIssuesGet[111] = taskIssue;
-
-      const adapter = makeAdapter();
-      await adapter.createTask({ epicRef: "FP-E110", title: "Sub-task" });
-
-      expect(lastAddSubIssueParams.length).toBeGreaterThan(0);
-      const subIssueCall = lastAddSubIssueParams[0];
-      expect(subIssueCall.issue_number).toBe(110);
-      expect(subIssueCall.sub_issue_id).toBe(111000);
-    });
-
-    test("flux-meta contains ref, epic_ref, prd_ref, priority", async () => {
-      const epicIssue = makeIssue({
-        number: 120,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E120","prd_ref":"FP-P12"}\n-->',
-      });
-
-      const taskIssue = makeIssue({
-        number: 121,
-        labels: ["flux:task", "priority:low"],
-        body: '<!-- flux-meta\n{"ref":"FP-T121","epic_ref":"FP-E120","prd_ref":"FP-P12","priority":"LOW","dependencies":[]}\n-->',
-        node_id: "NODE_121",
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E120": 120 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesCreate = taskIssue;
-      mockIssuesUpdate = taskIssue;
-      mockIssuesGet[120] = epicIssue;
-      mockIssuesGet[121] = taskIssue;
-
-      const adapter = makeAdapter();
-      await adapter.createTask({
-        epicRef: "FP-E120",
-        title: "Meta Check Task",
-        priority: "LOW",
-      });
-
-      const updateCall = lastUpdateByNumberParams[121];
-      expect(updateCall).toBeDefined();
-      expect(updateCall.body).toContain('"ref":"FP-T121"');
-      expect(updateCall.body).toContain('"epic_ref":"FP-E120"');
-      expect(updateCall.body).toContain('"prd_ref":"FP-P12"');
-      expect(updateCall.body).toContain('"priority":"LOW"');
-    });
-  });
-
-  describe("updateTask", () => {
-    test("updateTask status COMPLETED closes the issue", async () => {
-      const taskIssue = makeIssue({
-        number: 130,
-        labels: ["flux:task", "priority:medium"],
-        body: '<!-- flux-meta\n{"ref":"FP-T130","epic_ref":"FP-E13","prd_ref":"FP-P13","priority":"MEDIUM"}\n-->',
-      });
-
-      const closedTaskIssue = {
-        ...taskIssue,
-        state: "closed" as const,
-      };
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-T130": 130 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesGet[130] = taskIssue;
-      mockIssuesUpdate = closedTaskIssue;
-
-      const adapter = makeAdapter();
-      const task = await adapter.updateTask("FP-T130", { status: "COMPLETED" });
-
-      expect(lastUpdateByNumberParams[130]?.state).toBe("closed");
-      expect(task.status).toBe("COMPLETED");
-    });
-
-    test("updateTask priority change swaps old priority label for new one", async () => {
-      const taskIssue = makeIssue({
-        number: 135,
-        labels: ["flux:task", "priority:low"],
-        body: '<!-- flux-meta\n{"ref":"FP-T135","epic_ref":"FP-E13","prd_ref":"FP-P13","priority":"LOW"}\n-->',
-      });
-
-      const updatedTaskIssue = makeIssue({
-        number: 135,
-        labels: ["flux:task", "priority:high"],
-        body: '<!-- flux-meta\n{"ref":"FP-T135","epic_ref":"FP-E13","prd_ref":"FP-P13","priority":"HIGH"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-T135": 135 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesGet[135] = taskIssue;
-      mockIssuesUpdate = updatedTaskIssue;
-
-      const adapter = makeAdapter();
-      await adapter.updateTask("FP-T135", { priority: "HIGH" });
-
-      const updatedLabels: string[] =
-        lastUpdateByNumberParams[135]?.labels ?? [];
-      expect(updatedLabels).toContain("priority:high");
-      expect(updatedLabels).not.toContain("priority:low");
-    });
-  });
-
-  describe("getTask", () => {
-    test("returns null for unknown ref", async () => {
-      mockGetContent = null;
-      mockIssuesList = [];
-
-      const adapter = makeAdapter();
-      const result = await adapter.getTask("FP-T999");
-
-      expect(result).toBeNull();
-    });
-
-    test("returns correct Task with status and priority parsed from labels", async () => {
-      const taskIssue = makeIssue({
-        number: 140,
-        title: "My Task",
-        labels: ["flux:task", "status:in-progress", "priority:high"],
-        body: '<!-- flux-meta\n{"ref":"FP-T140","epic_ref":"FP-E14","prd_ref":"FP-P14","priority":"HIGH"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-T140": 140 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-      mockIssuesGet[140] = taskIssue;
-
-      const adapter = makeAdapter();
-      const task = await adapter.getTask("FP-T140");
-
-      expect(task).not.toBeNull();
-      expect(task?.ref).toBe("FP-T140");
-      expect(task?.status).toBe("IN_PROGRESS");
-      expect(task?.priority).toBe("HIGH");
-      expect(task?.epicId).toBe("FP-E14");
-    });
-  });
-
-  describe("listTasks", () => {
-    test("listTasks filtered by epic_ref returns only tasks belonging to that epic", async () => {
-      makeIssue({
-        number: 150,
-        labels: ["flux:epic"],
-        body: '<!-- flux-meta\n{"ref":"FP-E150","prd_ref":"FP-P15"}\n-->',
-      });
-
-      const taskIssue1 = makeIssue({
-        number: 151,
-        labels: ["flux:task", "priority:medium"],
-        body: '<!-- flux-meta\n{"ref":"FP-T151","epic_ref":"FP-E150"}\n-->',
-      });
-
-      const taskIssue2 = makeIssue({
-        number: 152,
-        labels: ["flux:task", "priority:low"],
-        body: '<!-- flux-meta\n{"ref":"FP-T152","epic_ref":"FP-E150"}\n-->',
-      });
-
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify({ "FP-E150": 150 })).toString(
-            "base64",
-          ),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesList = [taskIssue1, taskIssue2];
-
-      const adapter = makeAdapter();
-      const result = await adapter.listTasks({ epicRef: "FP-E150" });
-
-      expect(result.items.length).toBe(2);
-      expect(result.items[0].ref).toBe("FP-T151");
-      expect(result.items[1].ref).toBe("FP-T152");
-    });
-
-    test("listTasks filtered by status returns correct subset", async () => {
-      const pendingTask = makeIssue({
-        number: 160,
-        labels: ["flux:task", "priority:medium"],
-        body: '<!-- flux-meta\n{"ref":"FP-T160","epic_ref":"FP-E16"}\n-->',
-        state: "open",
-      });
-
-      const inProgressTask = makeIssue({
-        number: 161,
-        labels: ["flux:task", "status:in-progress", "priority:high"],
-        body: '<!-- flux-meta\n{"ref":"FP-T161","epic_ref":"FP-E16"}\n-->',
-        state: "open",
-      });
-
-      mockIssuesList = [pendingTask, inProgressTask];
-
-      const adapter = makeAdapter();
-      const result = await adapter.listTasks({ status: "IN_PROGRESS" });
-
-      expect(result.items.length).toBe(1);
-      expect(result.items[0].status).toBe("IN_PROGRESS");
-    });
-  });
-
-  describe("deleteTask", () => {
-    test("deleteTask closes issue and removes ref from index", async () => {
-      const taskIssue = makeIssue({
-        number: 170,
-        labels: ["flux:task", "priority:medium"],
-        body: '<!-- flux-meta\n{"ref":"FP-T170","epic_ref":"FP-E17"}\n-->',
-      });
-
-      const indexData = { "FP-T170": 170 };
-      mockGetContent = {
-        data: {
-          sha: "sha1",
-          content: Buffer.from(JSON.stringify(indexData)).toString("base64"),
-          encoding: "base64",
-        },
-      };
-
-      mockIssuesGet[170] = taskIssue;
-
-      const closedIssues: number[] = [];
-      const adapter = makeAdapter();
-      (adapter as any).client.rest.issues.update = async (params: any) => {
-        closedIssues.push(params.issue_number);
-        return { data: { ...taskIssue, state: "closed" } };
-      };
-
-      const result = await adapter.deleteTask("FP-T170");
-
-      expect(result.deleted).toBe("FP-T170");
-      expect(result.cascade.tasks).toBe(0);
-      expect(closedIssues).toContain(170);
-
-      const written = JSON.parse(
-        Buffer.from(lastPutParams.content, "base64").toString("utf-8"),
-      );
-      expect(written["FP-T170"]).toBeUndefined();
-    });
-  });
-});