@cliangdev/flux-plugin 0.3.1 → 0.4.0

package/src/server/adapters/github/adapter.ts

@@ -0,0 +1,1574 @@
+import type {
+  AcceptanceCriterion,
+  AddCriterionInput,
+  BackendAdapter,
+  CascadeResult,
+  CreateEpicInput,
+  CreatePrdInput,
+  CreateTaskInput,
+  Document,
+  Epic,
+  EpicFilters,
+  PaginatedResult,
+  PaginationOptions,
+  Prd,
+  PrdFilters,
+  Priority,
+  Stats,
+  Task,
+  TaskFilters,
+  UpdateEpicInput,
+  UpdatePrdInput,
+  UpdateTaskInput,
+} from "../types.js";
+import { GitHubClient } from "./client.js";
+import {
+  addCriterionToDescription,
+  generateCriteriaId,
+  parseCriteriaFromDescription,
+  updateCriterionInDescription,
+} from "./helpers/criteria.js";
+import { readIndex, writeIndex } from "./helpers/index-store.js";
+import {
+  decodeMeta,
+  encodeMeta,
+  extractDescription,
+  type FluxMeta,
+} from "./helpers/meta.js";
+import {
+  epicStatusToLabel,
+  getAllStatusLabels,
+  labelToEpicStatus,
+  labelToPrdStatus,
+  labelToPriority,
+  labelToTag,
+  labelToTaskStatus,
+  prdStatusToLabel,
+  priorityToLabel,
+  tagToLabel,
+  taskStatusToLabel,
+} from "./mappers/index.js";
+import { GITHUB_LABELS, type GitHubConfig } from "./types.js";
+
+interface GitHubIssue {
+  number: number;
+  id: number;
+  node_id: string;
+  title: string;
+  body: string | null;
+  state: string;
+  labels: Array<{ name: string }>;
+  created_at: string;
+  updated_at: string;
+}
+
+interface GitHubDirectoryEntry {
+  type: string;
+  name: string;
+  path: string;
+}
+
+function issueToPrd(issue: GitHubIssue, config: GitHubConfig): Prd {
+  const meta = decodeMeta(issue.body || "");
+  const labels = issue.labels.map((l) => l.name);
+  const ref = meta?.ref ?? `${config.refPrefix}-P${issue.number}`;
+  const refSlug = ref.toLowerCase().replace(":", "-");
+  const tag = labelToTag(labels) ?? meta?.tag;
+  return {
+    id: String(issue.number),
+    projectId: config.projectId,
+    ref,
+    title: issue.title,
+    description: extractDescription(issue.body || ""),
+    status: labelToPrdStatus(labels, issue.state === "closed"),
+    tag,
+    folderPath: `prds/${refSlug}/`,
+    createdAt: issue.created_at,
+    updatedAt: issue.updated_at,
+  };
+}
+
+export class GitHubAdapter implements BackendAdapter {
+  private config: GitHubConfig;
+  private client: GitHubClient;
+
+  constructor(config: GitHubConfig) {
+    this.config = config;
+    this.client = new GitHubClient(config);
+  }
+
+  async addToIndex(ref: string, issueNumber: number): Promise<void> {
+    const index = await readIndex(
+      this.client,
+      this.config.owner,
+      this.config.repo,
+    );
+    index[ref] = issueNumber;
+    await writeIndex(this.client, this.config.owner, this.config.repo, index);
+  }
+
+  async removeFromIndex(ref: string): Promise<void> {
+    const index = await readIndex(
+      this.client,
+      this.config.owner,
+      this.config.repo,
+    );
+    delete index[ref];
+    await writeIndex(this.client, this.config.owner, this.config.repo, index);
+  }
+
+  async resolveRef(ref: string, entityLabel: string): Promise<number | null> {
+    const index = await readIndex(
+      this.client,
+      this.config.owner,
+      this.config.repo,
+    );
+    if (index[ref] !== undefined) {
+      return index[ref];
+    }
+
+    const response = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: entityLabel,
+      state: "all",
+      per_page: 100,
+    });
+
+    const issues = response.data as Array<{
+      number: number;
+      body: string | null;
+    }>;
+    for (const issue of issues) {
+      if (issue.body?.includes(`"ref":"${ref}"`)) {
+        await this.addToIndex(ref, issue.number);
+        return issue.number;
+      }
+    }
+
+    return null;
+  }
+
+  private async addToProjectsBoard(issueNodeId: string): Promise<void> {
+    await this.client.graphql(
+      `
+      mutation AddToProject($projectId: ID!, $contentId: ID!) {
+        addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
+          item { id }
+        }
+      }
+    `,
+      { projectId: this.config.projectId, contentId: issueNodeId },
+    );
+  }
+
+  async createPrd(input: CreatePrdInput): Promise<Prd> {
+    const labels: string[] = [
+      GITHUB_LABELS.ENTITY_PRD,
+      GITHUB_LABELS.STATUS_DRAFT,
+    ];
+    if (input.tag) {
+      labels.push(tagToLabel(input.tag));
+    }
+
+    const tempMeta = encodeMeta({ ref: "TEMP", tag: input.tag });
+    const body = input.description
+      ? `${input.description}\n\n${tempMeta}`
+      : tempMeta;
+
+    const createResponse = await this.client.rest.issues.create({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      title: input.title,
+      body,
+      labels,
+    });
+
+    const createdIssue = createResponse.data as GitHubIssue;
+    const issueNumber = createdIssue.number;
+    const ref = `${this.config.refPrefix}-P${issueNumber}`;
+
+    const finalMeta = encodeMeta({
+      ref,
+      ...(input.tag ? { tag: input.tag } : {}),
+      dependencies: [],
+    });
+    const finalBody = input.description
+      ? `${input.description}\n\n${finalMeta}`
+      : finalMeta;
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: finalBody,
+    });
+
+    await this.addToProjectsBoard(createdIssue.node_id);
+    await this.addToIndex(ref, issueNumber);
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return issueToPrd(getResponse.data as GitHubIssue, this.config);
+  }
+
+  async updatePrd(ref: string, input: UpdatePrdInput): Promise<Prd> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_PRD);
+    if (issueNumber === null) {
+      throw new Error(`PRD not found: ${ref}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const existingIssue = getResponse.data as GitHubIssue;
+    const existingLabels: string[] = existingIssue.labels.map((l) => l.name);
+
+    const statusLabels = new Set(getAllStatusLabels());
+    const baseLabels = existingLabels.filter(
+      (l) => !statusLabels.has(l) && !l.startsWith(GITHUB_LABELS.TAG_PREFIX),
+    );
+
+    const newStatus =
+      input.status ??
+      labelToPrdStatus(existingLabels, existingIssue.state === "closed");
+    const statusLabel = prdStatusToLabel(newStatus);
+    if (statusLabel) {
+      baseLabels.push(statusLabel);
+    }
+
+    const newTag =
+      input.tag !== undefined ? input.tag : labelToTag(existingLabels);
+    if (newTag) {
+      baseLabels.push(tagToLabel(newTag));
+    }
+
+    const existingMeta = decodeMeta(existingIssue.body || "");
+    const updatedMeta = encodeMeta({
+      ref,
+      ...(existingMeta?.prd_ref ? { prd_ref: existingMeta.prd_ref } : {}),
+      ...(newTag ? { tag: newTag } : {}),
+      ...(existingMeta?.dependencies
+        ? { dependencies: existingMeta.dependencies }
+        : {}),
+    });
+
+    const cleanDescription =
+      input.description !== undefined
+        ? input.description
+        : extractDescription(existingIssue.body || "");
+    const newBody = cleanDescription
+      ? `${cleanDescription}\n\n${updatedMeta}`
+      : updatedMeta;
+
+    const updateParams: Record<string, unknown> = {
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      labels: baseLabels,
+      body: newBody,
+    };
+
+    if (input.title !== undefined) {
+      updateParams.title = input.title;
+    }
+
+    if (newStatus === "ARCHIVED") {
+      updateParams.state = "closed";
+    }
+
+    const updateResponse = await this.client.rest.issues.update(
+      updateParams as Parameters<typeof this.client.rest.issues.update>[0],
+    );
+
+    return issueToPrd(updateResponse.data as GitHubIssue, this.config);
+  }
+
+  async getPrd(ref: string): Promise<Prd | null> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_PRD);
+    if (issueNumber === null) return null;
+
+    const response = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return issueToPrd(response.data as GitHubIssue, this.config);
+  }
+
+  async listPrds(
+    filters?: PrdFilters,
+    pagination?: PaginationOptions,
+  ): Promise<PaginatedResult<Prd>> {
+    const limit = pagination?.limit ?? 50;
+    const offset = pagination?.offset ?? 0;
+
+    const labelFilters: string[] = [GITHUB_LABELS.ENTITY_PRD];
+    if (filters?.status) {
+      const statusLabel = prdStatusToLabel(filters.status);
+      if (statusLabel) {
+        labelFilters.push(statusLabel);
+      }
+    }
+    if (filters?.tag) {
+      labelFilters.push(tagToLabel(filters.tag));
+    }
+
+    const response = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: labelFilters.join(","),
+      state: "all",
+      per_page: 100,
+      page: 1,
+    });
+
+    const allIssues = response.data as GitHubIssue[];
+    const total = allIssues.length;
+    const paginated = allIssues.slice(offset, offset + limit);
+
+    return {
+      items: paginated.map((issue) => issueToPrd(issue, this.config)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total,
+    };
+  }
+
+  async deletePrd(
+    ref: string,
+  ): Promise<{ deleted: string; cascade: CascadeResult }> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_PRD);
+    if (issueNumber === null) {
+      throw new Error(`PRD not found: ${ref}`);
+    }
+
+    let epicCount = 0;
+    let taskCount = 0;
+
+    const epicsResponse = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: GITHUB_LABELS.ENTITY_EPIC,
+      state: "all",
+      per_page: 100,
+    });
+
+    const epics = (epicsResponse.data as GitHubIssue[]).filter((issue) => {
+      const meta = decodeMeta(issue.body || "");
+      return meta?.prd_ref === ref;
+    });
+
+    for (const epicIssue of epics) {
+      const epicMeta = decodeMeta(epicIssue.body || "");
+      const epicRef =
+        epicMeta?.ref ?? `${this.config.refPrefix}-E${epicIssue.number}`;
+
+      const tasksResponse = await this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_TASK,
+        state: "all",
+        per_page: 100,
+      });
+
+      const tasks = (tasksResponse.data as GitHubIssue[]).filter((issue) => {
+        const meta = decodeMeta(issue.body || "");
+        return meta?.epic_ref === epicRef;
+      });
+
+      for (const taskIssue of tasks) {
+        const taskMeta = decodeMeta(taskIssue.body || "");
+        const taskRef =
+          taskMeta?.ref ?? `${this.config.refPrefix}-T${taskIssue.number}`;
+
+        await this.client.rest.issues.update({
+          owner: this.config.owner,
+          repo: this.config.repo,
+          issue_number: taskIssue.number,
+          state: "closed",
+        });
+        await this.removeFromIndex(taskRef);
+        taskCount++;
+      }
+
+      await this.client.rest.issues.update({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        issue_number: epicIssue.number,
+        state: "closed",
+      });
+      await this.removeFromIndex(epicRef);
+      epicCount++;
+    }
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      state: "closed",
+    });
+    await this.removeFromIndex(ref);
+
+    return {
+      deleted: ref,
+      cascade: {
+        epics: epicCount,
+        tasks: taskCount,
+        criteria: 0,
+        dependencies: 0,
+      },
+    };
+  }
+
+  private issueToEpic(issue: GitHubIssue): Epic {
+    const meta = decodeMeta(issue.body || "");
+    const labels = issue.labels.map((l) => l.name);
+    return {
+      id: String(issue.number),
+      prdId: meta?.prd_ref || "",
+      ref: meta?.ref || `${this.config.refPrefix}-E${issue.number}`,
+      title: issue.title,
+      description: extractDescription(issue.body || ""),
+      status: labelToEpicStatus(labels, issue.state === "closed"),
+      createdAt: issue.created_at,
+      updatedAt: issue.updated_at,
+    };
+  }
+
+  private issueToTask(issue: GitHubIssue): Task {
+    const meta = decodeMeta(issue.body || "");
+    const labels = issue.labels.map((l) => l.name);
+    return {
+      id: String(issue.number),
+      epicId: meta?.epic_ref || "",
+      ref: meta?.ref || `${this.config.refPrefix}-T${issue.number}`,
+      title: issue.title,
+      description: extractDescription(issue.body || ""),
+      status: labelToTaskStatus(labels, issue.state === "closed"),
+      priority: labelToPriority(labels),
+      createdAt: issue.created_at,
+      updatedAt: issue.updated_at,
+    };
+  }
+
+  async createEpic(input: CreateEpicInput): Promise<Epic> {
+    const prdIssueNum = await this.resolveRef(
+      input.prdRef,
+      GITHUB_LABELS.ENTITY_PRD,
+    );
+    if (prdIssueNum === null) {
+      throw new Error(`PRD not found: ${input.prdRef}`);
+    }
+
+    const labels: string[] = [GITHUB_LABELS.ENTITY_EPIC];
+
+    const tempMeta = encodeMeta({ ref: "TEMP", prd_ref: input.prdRef });
+    const body = input.description
+      ? `${input.description}\n\n${tempMeta}`
+      : tempMeta;
+
+    const createResponse = await this.client.rest.issues.create({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      title: input.title,
+      body,
+      labels,
+    });
+
+    const createdIssue = createResponse.data as GitHubIssue;
+    const issueNumber = createdIssue.number;
+    const ref = `${this.config.refPrefix}-E${issueNumber}`;
+
+    const acSection =
+      input.acceptanceCriteria && input.acceptanceCriteria.length > 0
+        ? `\n\n## Acceptance Criteria\n${input.acceptanceCriteria.map((c) => `- [ ] ${c}`).join("\n")}`
+        : "";
+
+    const finalMeta = encodeMeta({
+      ref,
+      prd_ref: input.prdRef,
+      dependencies: [],
+    });
+    const descriptionPart = input.description ? `${input.description}` : "";
+    const finalBody = descriptionPart
+      ? `${descriptionPart}${acSection}\n\n${finalMeta}`
+      : `${acSection ? `${acSection.trim()}\n\n` : ""}${finalMeta}`;
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: finalBody,
+    });
+
+    try {
+      await this.client.rest.request(
+        "POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues",
+        {
+          owner: this.config.owner,
+          repo: this.config.repo,
+          issue_number: prdIssueNum,
+          sub_issue_id: createdIssue.id,
+        },
+      );
+    } catch {
+      // sub-issue linking is cosmetic for GitHub UI; hierarchy is stored in flux-meta
+    }
+
+    await this.addToProjectsBoard(createdIssue.node_id);
+    await this.addToIndex(ref, issueNumber);
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return this.issueToEpic(getResponse.data as GitHubIssue);
+  }
+
+  async updateEpic(ref: string, input: UpdateEpicInput): Promise<Epic> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_EPIC);
+    if (issueNumber === null) {
+      throw new Error(`Epic not found: ${ref}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const existingIssue = getResponse.data as GitHubIssue;
+    const existingLabels: string[] = existingIssue.labels.map((l) => l.name);
+
+    const statusLabelToRemove = GITHUB_LABELS.STATUS_IN_PROGRESS;
+    const baseLabels = existingLabels.filter((l) => l !== statusLabelToRemove);
+
+    const newStatus =
+      input.status ??
+      labelToEpicStatus(existingLabels, existingIssue.state === "closed");
+    const statusLabel = epicStatusToLabel(newStatus);
+    if (statusLabel) {
+      baseLabels.push(statusLabel);
+    }
+
+    const existingMeta = decodeMeta(existingIssue.body || "");
+    const updatedMeta = encodeMeta({
+      ref,
+      ...(existingMeta?.prd_ref ? { prd_ref: existingMeta.prd_ref } : {}),
+      ...(existingMeta?.dependencies
+        ? { dependencies: existingMeta.dependencies }
+        : {}),
+    });
+
+    const cleanDescription =
+      input.description !== undefined
+        ? input.description
+        : extractDescription(existingIssue.body || "");
+    const newBody = cleanDescription
+      ? `${cleanDescription}\n\n${updatedMeta}`
+      : updatedMeta;
+
+    const updateParams: Record<string, unknown> = {
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      labels: baseLabels,
+      body: newBody,
+    };
+
+    if (input.title !== undefined) {
+      updateParams.title = input.title;
+    }
+
+    if (newStatus === "COMPLETED") {
+      updateParams.state = "closed";
+    }
+
+    const updateResponse = await this.client.rest.issues.update(
+      updateParams as Parameters<typeof this.client.rest.issues.update>[0],
+    );
+
+    return this.issueToEpic(updateResponse.data as GitHubIssue);
+  }
+
+  async getEpic(ref: string): Promise<Epic | null> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_EPIC);
+    if (issueNumber === null) return null;
+
+    const response = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return this.issueToEpic(response.data as GitHubIssue);
+  }
+
+  async listEpics(
+    filters?: EpicFilters,
+    pagination?: PaginationOptions,
+  ): Promise<PaginatedResult<Epic>> {
+    const limit = pagination?.limit ?? 50;
+    const offset = pagination?.offset ?? 0;
+
+    let allIssues: GitHubIssue[];
+
+    if (filters?.prdRef) {
+      const response = await this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_EPIC,
+        state: "all",
+        per_page: 100,
+      });
+      allIssues = (response.data as GitHubIssue[]).filter((issue) => {
+        const meta = decodeMeta(issue.body || "");
+        return meta?.prd_ref === filters.prdRef;
+      });
+    } else {
+      const labelFilters: string[] = [GITHUB_LABELS.ENTITY_EPIC];
+      if (filters?.status) {
+        const statusLabel = epicStatusToLabel(filters.status);
+        if (statusLabel) {
+          labelFilters.push(statusLabel);
+        }
+      }
+
+      const response = await this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: labelFilters.join(","),
+        state: filters?.status === "COMPLETED" ? "closed" : "all",
+        per_page: 100,
+        page: 1,
+      });
+      allIssues = response.data as GitHubIssue[];
+    }
+
+    if (filters?.status) {
+      allIssues = allIssues.filter((issue) => {
+        const labels = issue.labels.map((l) => l.name);
+        return (
+          labelToEpicStatus(labels, issue.state === "closed") === filters.status
+        );
+      });
+    }
+
+    const total = allIssues.length;
+    const paginated = allIssues.slice(offset, offset + limit);
+
+    return {
+      items: paginated.map((issue) => this.issueToEpic(issue)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total,
+    };
+  }
+
+  async deleteEpic(
+    ref: string,
+  ): Promise<{ deleted: string; cascade: CascadeResult }> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_EPIC);
+    if (issueNumber === null) {
+      throw new Error(`Epic not found: ${ref}`);
+    }
+
+    let taskCount = 0;
+
+    const tasksResponse = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: GITHUB_LABELS.ENTITY_TASK,
+      state: "all",
+      per_page: 100,
+    });
+
+    const tasks = (tasksResponse.data as GitHubIssue[]).filter((issue) => {
+      const meta = decodeMeta(issue.body || "");
+      return meta?.epic_ref === ref;
+    });
+
+    for (const taskIssue of tasks) {
+      const taskMeta = decodeMeta(taskIssue.body || "");
+      const taskRef =
+        taskMeta?.ref ?? `${this.config.refPrefix}-T${taskIssue.number}`;
+
+      await this.client.rest.issues.update({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        issue_number: taskIssue.number,
+        state: "closed",
+      });
+      await this.removeFromIndex(taskRef);
+      taskCount++;
+    }
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      state: "closed",
+    });
+    await this.removeFromIndex(ref);
+
+    return {
+      deleted: ref,
+      cascade: {
+        tasks: taskCount,
+        epics: 0,
+        criteria: 0,
+        dependencies: 0,
+      },
+    };
+  }
+
+  async createTask(input: CreateTaskInput): Promise<Task> {
+    const epicIssueNum = await this.resolveRef(
+      input.epicRef,
+      GITHUB_LABELS.ENTITY_EPIC,
+    );
+    if (epicIssueNum === null) {
+      throw new Error(`Epic not found: ${input.epicRef}`);
+    }
+
+    const epicResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: epicIssueNum,
+    });
+    const epicData = epicResponse.data as GitHubIssue;
+    const epicMeta = decodeMeta(epicData.body || "");
+    const prdRef = epicMeta?.prd_ref || "";
+
+    const priority: Priority = input.priority ?? "MEDIUM";
+    const labels: string[] = [
+      GITHUB_LABELS.ENTITY_TASK,
+      priorityToLabel(priority),
+    ];
+
+    const tempMeta = encodeMeta({
+      ref: "TEMP",
+      epic_ref: input.epicRef,
+      prd_ref: prdRef,
+      priority,
+    });
+    const body = input.description
+      ? `${input.description}\n\n${tempMeta}`
+      : tempMeta;
+
+    const createResponse = await this.client.rest.issues.create({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      title: input.title,
+      body,
+      labels,
+    });
+
+    const createdIssue = createResponse.data as GitHubIssue;
+    const issueNumber = createdIssue.number;
+    const ref = `${this.config.refPrefix}-T${issueNumber}`;
+
+    const acSection =
+      input.acceptanceCriteria && input.acceptanceCriteria.length > 0
+        ? `\n\n## Acceptance Criteria\n${input.acceptanceCriteria.map((c) => `- [ ] ${c}`).join("\n")}`
+        : "";
+
+    const finalMeta = encodeMeta({
+      ref,
+      epic_ref: input.epicRef,
+      prd_ref: prdRef,
+      priority,
+      dependencies: [],
+    });
+    const descriptionPart = input.description ? `${input.description}` : "";
+    const finalBody = descriptionPart
+      ? `${descriptionPart}${acSection}\n\n${finalMeta}`
+      : `${acSection ? `${acSection.trim()}\n\n` : ""}${finalMeta}`;
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: finalBody,
+    });
+
+    try {
+      await this.client.rest.request(
+        "POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues",
+        {
+          owner: this.config.owner,
+          repo: this.config.repo,
+          issue_number: epicIssueNum,
+          sub_issue_id: createdIssue.id,
+        },
+      );
+    } catch {
+      // sub-issue linking is cosmetic for GitHub UI; hierarchy is in flux-meta
+    }
+
+    await this.addToProjectsBoard(createdIssue.node_id);
+    await this.addToIndex(ref, issueNumber);
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return this.issueToTask(getResponse.data as GitHubIssue);
+  }
+
+  async updateTask(ref: string, input: UpdateTaskInput): Promise<Task> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_TASK);
+    if (issueNumber === null) {
+      throw new Error(`Task not found: ${ref}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const existingIssue = getResponse.data as GitHubIssue;
+    const existingLabels: string[] = existingIssue.labels.map((l) => l.name);
+
+    const priorityLabels = new Set<string>([
+      GITHUB_LABELS.PRIORITY_LOW,
+      GITHUB_LABELS.PRIORITY_MEDIUM,
+      GITHUB_LABELS.PRIORITY_HIGH,
+    ]);
+    const baseLabels = existingLabels.filter(
+      (l) => l !== GITHUB_LABELS.STATUS_IN_PROGRESS && !priorityLabels.has(l),
+    );
+
+    const newStatus =
+      input.status ??
+      labelToTaskStatus(existingLabels, existingIssue.state === "closed");
+    const statusLabel = taskStatusToLabel(newStatus);
+    if (statusLabel) {
+      baseLabels.push(statusLabel);
+    }
+
+    const newPriority = input.priority ?? labelToPriority(existingLabels);
+    baseLabels.push(priorityToLabel(newPriority));
+
+    const existingMeta = decodeMeta(existingIssue.body || "");
+    const updatedMeta = encodeMeta({
+      ref,
+      ...(existingMeta?.epic_ref ? { epic_ref: existingMeta.epic_ref } : {}),
+      ...(existingMeta?.prd_ref ? { prd_ref: existingMeta.prd_ref } : {}),
+      priority: newPriority,
+      ...(existingMeta?.dependencies
+        ? { dependencies: existingMeta.dependencies }
+        : {}),
+    });
+
+    const cleanDescription =
+      input.description !== undefined
+        ? input.description
+        : extractDescription(existingIssue.body || "");
+    const newBody = cleanDescription
+      ? `${cleanDescription}\n\n${updatedMeta}`
+      : updatedMeta;
+
+    const updateParams: Record<string, unknown> = {
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      labels: baseLabels,
+      body: newBody,
+    };
+
+    if (input.title !== undefined) {
+      updateParams.title = input.title;
+    }
+
+    if (newStatus === "COMPLETED") {
+      updateParams.state = "closed";
+    }
+
+    const updateResponse = await this.client.rest.issues.update(
+      updateParams as Parameters<typeof this.client.rest.issues.update>[0],
+    );
+
+    return this.issueToTask(updateResponse.data as GitHubIssue);
+  }
+
+  async getTask(ref: string): Promise<Task | null> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_TASK);
+    if (issueNumber === null) return null;
+
+    const response = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+
+    return this.issueToTask(response.data as GitHubIssue);
+  }
+
+  async listTasks(
+    filters?: TaskFilters,
+    pagination?: PaginationOptions,
+  ): Promise<PaginatedResult<Task>> {
+    const limit = pagination?.limit ?? 50;
+    const offset = pagination?.offset ?? 0;
+
+    let allIssues: GitHubIssue[];
+
+    if (filters?.epicRef) {
+      const response = await this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_TASK,
+        state: "all",
+        per_page: 100,
+      });
+      allIssues = (response.data as GitHubIssue[]).filter((issue) => {
+        const meta = decodeMeta(issue.body || "");
+        return meta?.epic_ref === filters.epicRef;
+      });
+    } else {
+      const labelFilters: string[] = [GITHUB_LABELS.ENTITY_TASK];
+      if (filters?.status) {
+        const statusLabel = taskStatusToLabel(filters.status);
+        if (statusLabel) {
+          labelFilters.push(statusLabel);
+        }
+      }
+      if (filters?.priority) {
+        labelFilters.push(priorityToLabel(filters.priority));
+      }
+
+      const response = await this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: labelFilters.join(","),
+        state: filters?.status === "COMPLETED" ? "closed" : "all",
+        per_page: 100,
+        page: 1,
+      });
+      allIssues = response.data as GitHubIssue[];
+    }
+
+    if (filters?.status) {
+      allIssues = allIssues.filter((issue) => {
+        const labels = issue.labels.map((l) => l.name);
+        return (
+          labelToTaskStatus(labels, issue.state === "closed") === filters.status
+        );
+      });
+    }
+
+    const total = allIssues.length;
+    const paginated = allIssues.slice(offset, offset + limit);
+
+    return {
+      items: paginated.map((issue) => this.issueToTask(issue)),
+      total,
+      limit,
+      offset,
+      hasMore: offset + limit < total,
+    };
+  }
+
+  async deleteTask(
+    ref: string,
+  ): Promise<{ deleted: string; cascade: CascadeResult }> {
+    const issueNumber = await this.resolveRef(ref, GITHUB_LABELS.ENTITY_TASK);
+    if (issueNumber === null) {
+      throw new Error(`Task not found: ${ref}`);
+    }
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      state: "closed",
+    });
+    await this.removeFromIndex(ref);
+
+    return {
+      deleted: ref,
+      cascade: {
+        tasks: 0,
+        epics: 0,
+        criteria: 0,
+        dependencies: 0,
+      },
+    };
+  }
+
+  private getEntityLabel(ref: string): string {
+    if (ref.includes("-P")) return GITHUB_LABELS.ENTITY_PRD;
+    if (ref.includes("-E")) return GITHUB_LABELS.ENTITY_EPIC;
+    if (ref.includes("-T")) return GITHUB_LABELS.ENTITY_TASK;
+    throw new Error(`Cannot determine entity type from ref: ${ref}`);
+  }
+
+  private getParentType(ref: string): "epic" | "task" {
+    if (ref.includes("-E")) return "epic";
+    return "task";
+  }
+
+  private updateMetaInBody(body: string, newMeta: FluxMeta): string {
+    const newMetaBlock = encodeMeta(newMeta);
+    if (body.includes("<!-- flux-meta")) {
+      return body.replace(/<!--\s*flux-meta[\s\S]*?-->/, newMetaBlock);
+    }
+    return `${body}\n\n${newMetaBlock}`;
+  }
+
+  async addCriterion(input: AddCriterionInput): Promise<AcceptanceCriterion> {
+    const entityLabel = this.getEntityLabel(input.parentRef);
+    const issueNumber = await this.resolveRef(input.parentRef, entityLabel);
+    if (issueNumber === null) {
+      throw new Error(`Entity not found: ${input.parentRef}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const currentBody = (getResponse.data as GitHubIssue).body ?? "";
+
+    const newBody = addCriterionToDescription(currentBody, input.criteria);
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: newBody,
+    });
+
+    return {
+      id: generateCriteriaId(input.criteria),
+      parentType: this.getParentType(input.parentRef),
+      parentId: issueNumber.toString(),
+      criteria: input.criteria,
+      isMet: false,
+      createdAt: new Date().toISOString(),
+    };
+  }
+
+  async markCriterionMet(criterionId: string): Promise<AcceptanceCriterion> {
+    const allIssues: GitHubIssue[] = [];
+
+    const epicResponse = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: GITHUB_LABELS.ENTITY_EPIC,
+      state: "open",
+      per_page: 100,
+    });
+    allIssues.push(...(epicResponse.data as GitHubIssue[]));
+
+    const taskResponse = await this.client.rest.issues.listForRepo({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      labels: GITHUB_LABELS.ENTITY_TASK,
+      state: "open",
+      per_page: 100,
+    });
+    allIssues.push(...(taskResponse.data as GitHubIssue[]));
+
+    for (const issue of allIssues) {
+      const body = issue.body ?? "";
+      const criteria = parseCriteriaFromDescription(body);
+      const found = criteria.find((c) => c.id === criterionId);
+      if (found) {
+        const newBody = updateCriterionInDescription(body, criterionId, true);
+        await this.client.rest.issues.update({
+          owner: this.config.owner,
+          repo: this.config.repo,
+          issue_number: issue.number,
+          body: newBody,
+        });
+
+        const labels: string[] = issue.labels.map((l) => l.name);
+        const parentType = labels.includes(GITHUB_LABELS.ENTITY_EPIC)
+          ? "epic"
+          : "task";
+
+        return {
+          id: criterionId,
+          parentType,
+          parentId: String(issue.number),
+          criteria: found.text,
+          isMet: true,
+          createdAt: new Date().toISOString(),
+        };
+      }
+    }
+
+    throw new Error(`Criterion not found: ${criterionId}`);
+  }
+
+  async getCriteria(parentRef: string): Promise<AcceptanceCriterion[]> {
+    const entityLabel = this.getEntityLabel(parentRef);
+    const issueNumber = await this.resolveRef(parentRef, entityLabel);
+    if (issueNumber === null) {
+      throw new Error(`Entity not found: ${parentRef}`);
+    }
+
+    const response = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const body = (response.data as GitHubIssue).body ?? "";
+    const parsed = parseCriteriaFromDescription(body);
+    const parentType = this.getParentType(parentRef);
+
+    return parsed.map((c) => ({
+      id: c.id,
+      parentType,
+      parentId: issueNumber.toString(),
+      criteria: c.text,
+      isMet: c.isMet,
+      createdAt: new Date().toISOString(),
+    }));
+  }
+
+  async addDependency(ref: string, dependsOnRef: string): Promise<void> {
+    if (ref === dependsOnRef) {
+      throw new Error("Cannot add self-dependency");
+    }
+
+    const refType = ref.includes("-P")
+      ? "prd"
+      : ref.includes("-E")
+        ? "epic"
+        : "task";
+    const depType = dependsOnRef.includes("-P")
+      ? "prd"
+      : dependsOnRef.includes("-E")
+        ? "epic"
+        : "task";
+
+    if (refType !== depType) {
+      throw new Error("Dependencies must be between entities of the same type");
+    }
+
+    const entityLabel = this.getEntityLabel(ref);
+    const issueNumber = await this.resolveRef(ref, entityLabel);
+    if (issueNumber === null) {
+      throw new Error(`Entity not found: ${ref}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const currentBody = (getResponse.data as GitHubIssue).body ?? "";
+    const meta = decodeMeta(currentBody);
+
+    if (!meta) {
+      throw new Error(`No flux-meta found in issue for ref: ${ref}`);
+    }
+
+    const existing = meta.dependencies ?? [];
+    if (!existing.includes(dependsOnRef)) {
+      meta.dependencies = [...existing, dependsOnRef];
+    }
+
+    const newBody = this.updateMetaInBody(currentBody, meta);
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: newBody,
+    });
+  }
+
+  async removeDependency(ref: string, dependsOnRef: string): Promise<void> {
+    const entityLabel = this.getEntityLabel(ref);
+    const issueNumber = await this.resolveRef(ref, entityLabel);
+    if (issueNumber === null) {
+      throw new Error(`Entity not found: ${ref}`);
+    }
+
+    const getResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const currentBody = (getResponse.data as GitHubIssue).body ?? "";
+    const meta = decodeMeta(currentBody);
+
+    if (!meta) {
+      return;
+    }
+
+    meta.dependencies = (meta.dependencies ?? []).filter(
+      (d) => d !== dependsOnRef,
+    );
+
+    const newBody = this.updateMetaInBody(currentBody, meta);
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: newBody,
+    });
+  }
+
+  async getDependencies(ref: string): Promise<string[]> {
+    const entityLabel = this.getEntityLabel(ref);
+    const issueNumber = await this.resolveRef(ref, entityLabel);
+    if (issueNumber === null) {
+      throw new Error(`Entity not found: ${ref}`);
+    }
+
+    const response = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const body = (response.data as GitHubIssue).body ?? "";
+    const meta = decodeMeta(body);
+
+    return meta?.dependencies ?? [];
+  }
+
+  private refSlug(ref: string): string {
+    return ref.toLowerCase().replace(":", "-");
+  }
+
+  private blobUrl(path: string): string {
+    return `https://github.com/${this.config.owner}/${this.config.repo}/blob/main/${path}`;
+  }
+
+  private async getFileSha(path: string): Promise<string | null> {
+    try {
+      const response = await this.client.rest.repos.getContent({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        path,
+      });
+      const data = response.data as { sha: string };
+      return data.sha;
+    } catch (err: unknown) {
+      if ((err as { status?: number }).status === 404) return null;
+      throw err;
+    }
+  }
+
+  private addDocumentLink(body: string, filename: string, url: string): string {
+    const link = `- [${filename}](${url})`;
+    const sectionHeader = "## Supporting Documents";
+    const sectionIndex = body.indexOf(sectionHeader);
+
+    if (sectionIndex === -1) {
+      return `${body}\n\n${sectionHeader}\n\n${link}`;
+    }
+
+    const before = body.slice(0, sectionIndex + sectionHeader.length);
+    const after = body.slice(sectionIndex + sectionHeader.length);
+
+    const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const existingLinkPattern = new RegExp(
+      `- \\[${escapedFilename}\\]\\([^)]+\\)`,
+    );
+
+    if (existingLinkPattern.test(after)) {
+      return before + after.replace(existingLinkPattern, link);
+    }
+
+    const doubleNewlineIdx = after.search(/\n\n/);
+    if (doubleNewlineIdx === -1) {
+      return `${before}${after}\n${link}`;
+    }
+    return (
+      before +
+      after.slice(0, doubleNewlineIdx) +
+      "\n" +
+      link +
+      after.slice(doubleNewlineIdx)
+    );
+  }
+
+  private removeDocumentLink(body: string, filename: string): string {
+    const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const linkPattern = new RegExp(`\n- \\[${escapedFilename}\\]\\([^)]+\\)`);
+    return body.replace(linkPattern, "");
+  }
+
+  async saveDocument(doc: Document): Promise<Document> {
+    const issueNumber = await this.resolveRef(
+      doc.prdRef,
+      GITHUB_LABELS.ENTITY_PRD,
+    );
+    if (issueNumber === null) {
+      throw new Error(`PRD not found: ${doc.prdRef}`);
+    }
+
+    const slug = this.refSlug(doc.prdRef);
+    const filePath = `prds/${slug}/${doc.filename}`;
+    const existingSha = await this.getFileSha(filePath);
+
+    const putParams: Record<string, unknown> = {
+      owner: this.config.owner,
+      repo: this.config.repo,
+      path: filePath,
+      message: `docs: save ${doc.filename} for ${doc.prdRef}`,
+      content: Buffer.from(doc.content).toString("base64"),
+    };
+
+    if (existingSha !== null) {
+      putParams.sha = existingSha;
+    }
+
+    await this.client.rest.repos.createOrUpdateFileContents(
+      putParams as Parameters<
+        typeof this.client.rest.repos.createOrUpdateFileContents
+      >[0],
+    );
+
+    const blobUrl = this.blobUrl(filePath);
+
+    const issueResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const currentBody = (issueResponse.data as GitHubIssue).body ?? "";
+    const updatedBody = this.addDocumentLink(
+      currentBody,
+      doc.filename,
+      blobUrl,
+    );
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: updatedBody,
+    });
+
+    return { ...doc, url: blobUrl };
+  }
+
+  async getDocuments(prdRef: string): Promise<Document[]> {
+    const slug = this.refSlug(prdRef);
+    const dirPath = `prds/${slug}`;
+
+    let entries: GitHubDirectoryEntry[];
+    try {
+      const response = await this.client.rest.repos.getContent({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        path: dirPath,
+      });
+      entries = response.data as GitHubDirectoryEntry[];
+    } catch (err: unknown) {
+      if ((err as { status?: number }).status === 404) return [];
+      throw err;
+    }
+
+    const mdFiles = entries.filter(
+      (entry) => entry.type === "file" && entry.name.endsWith(".md"),
+    );
+
+    const documents: Document[] = [];
+    for (const file of mdFiles) {
+      const fileResponse = await this.client.rest.repos.getContent({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        path: file.path,
+      });
+      const fileData = fileResponse.data as {
+        content: string;
+        encoding: string;
+      };
+      const content = Buffer.from(fileData.content, "base64").toString("utf-8");
+
+      documents.push({
+        prdRef,
+        filename: file.name,
+        content,
+        url: this.blobUrl(file.path),
+      });
+    }
+
+    return documents;
+  }
+
+  async deleteDocument(prdRef: string, filename: string): Promise<void> {
+    const issueNumber = await this.resolveRef(prdRef, GITHUB_LABELS.ENTITY_PRD);
+    if (issueNumber === null) {
+      throw new Error(`PRD not found: ${prdRef}`);
+    }
+
+    const slug = this.refSlug(prdRef);
+    const filePath = `prds/${slug}/${filename}`;
+    const sha = await this.getFileSha(filePath);
+
+    if (sha !== null) {
+      await this.client.rest.repos.deleteFile({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        path: filePath,
+        message: `docs: delete ${filename}`,
+        sha,
+      });
+    }
+
+    const issueResponse = await this.client.rest.issues.get({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+    });
+    const currentBody = (issueResponse.data as GitHubIssue).body ?? "";
+    const updatedBody = this.removeDocumentLink(currentBody, filename);
+
+    await this.client.rest.issues.update({
+      owner: this.config.owner,
+      repo: this.config.repo,
+      issue_number: issueNumber,
+      body: updatedBody,
+    });
+  }
+
+  async getStats(): Promise<Stats> {
+    const [
+      openPrds,
+      closedPrds,
+      openEpics,
+      closedEpics,
+      openTasks,
+      closedTasks,
+    ] = await Promise.all([
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_PRD,
+        state: "open",
+        per_page: 100,
+      }),
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_PRD,
+        state: "closed",
+        per_page: 100,
+      }),
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_EPIC,
+        state: "open",
+        per_page: 100,
+      }),
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_EPIC,
+        state: "closed",
+        per_page: 100,
+      }),
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_TASK,
+        state: "open",
+        per_page: 100,
+      }),
+      this.client.rest.issues.listForRepo({
+        owner: this.config.owner,
+        repo: this.config.repo,
+        labels: GITHUB_LABELS.ENTITY_TASK,
+        state: "closed",
+        per_page: 100,
+      }),
+    ]);
+
+    const openPrdIssues = openPrds.data as GitHubIssue[];
+    const closedPrdIssues = closedPrds.data as GitHubIssue[];
+    const openEpicIssues = openEpics.data as GitHubIssue[];
+    const closedEpicIssues = closedEpics.data as GitHubIssue[];
+    const openTaskIssues = openTasks.data as GitHubIssue[];
+    const closedTaskIssues = closedTasks.data as GitHubIssue[];
+
+    const prdStats = {
+      total: openPrdIssues.length,
+      draft: 0,
+      pendingReview: 0,
+      reviewed: 0,
+      approved: 0,
+      breakdownReady: 0,
+      completed: 0,
+      archived: closedPrdIssues.length,
+    };
+
+    for (const issue of openPrdIssues) {
+      const labels = issue.labels.map((l) => l.name);
+      if (labels.includes(GITHUB_LABELS.STATUS_COMPLETED)) {
+        prdStats.completed++;
+      } else if (labels.includes(GITHUB_LABELS.STATUS_BREAKDOWN_READY)) {
+        prdStats.breakdownReady++;
+      } else if (labels.includes(GITHUB_LABELS.STATUS_APPROVED)) {
+        prdStats.approved++;
+      } else if (labels.includes(GITHUB_LABELS.STATUS_REVIEWED)) {
+        prdStats.reviewed++;
+      } else if (labels.includes(GITHUB_LABELS.STATUS_PENDING_REVIEW)) {
+        prdStats.pendingReview++;
+      } else {
+        prdStats.draft++;
+      }
+    }
+
+    const epicPending = openEpicIssues.filter((issue) => {
+      const labels = issue.labels.map((l) => l.name);
+      return !labels.includes(GITHUB_LABELS.STATUS_IN_PROGRESS);
+    }).length;
+
+    const epicInProgress = openEpicIssues.filter((issue) => {
+      const labels = issue.labels.map((l) => l.name);
+      return labels.includes(GITHUB_LABELS.STATUS_IN_PROGRESS);
+    }).length;
+
+    const epicCompleted = closedEpicIssues.length;
+
+    const taskPending = openTaskIssues.filter((issue) => {
+      const labels = issue.labels.map((l) => l.name);
+      return !labels.includes(GITHUB_LABELS.STATUS_IN_PROGRESS);
+    }).length;
+
+    const taskInProgress = openTaskIssues.filter((issue) => {
+      const labels = issue.labels.map((l) => l.name);
+      return labels.includes(GITHUB_LABELS.STATUS_IN_PROGRESS);
+    }).length;
+
+    const taskCompleted = closedTaskIssues.length;
+
+    return {
+      prds: prdStats,
+      epics: {
+        total: openEpicIssues.length + epicCompleted,
+        pending: epicPending,
+        inProgress: epicInProgress,
+        completed: epicCompleted,
+      },
+      tasks: {
+        total: openTaskIssues.length + taskCompleted,
+        pending: taskPending,
+        inProgress: taskInProgress,
+        completed: taskCompleted,
+      },
+    };
+  }
+}