@gh-symphony/cli 0.0.19 → 0.0.21

package/dist/chunk-SXGT7LOF.js

@@ -0,0 +1,1060 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_WORKFLOW_LIFECYCLE
+} from "./chunk-QEONJ5DZ.js";
+
+// ../tracker-github/src/adapter.ts
+import { createHash } from "crypto";
+var DEFAULT_API_URL = "https://api.github.com/graphql";
+var DEFAULT_PAGE_SIZE = 25;
+var DEFAULT_NETWORK_TIMEOUT_MS = 3e4;
+var RATE_LIMIT_THRESHOLD = 100;
+var MAX_RATE_LIMIT_WAIT_MS = 6e4;
+var GitHubTrackerError = class extends Error {
+};
+var GitHubTrackerHttpError = class extends GitHubTrackerError {
+  constructor(message, status, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+  }
+};
+var GitHubTrackerQueryError = class extends GitHubTrackerError {
+};
+var cachedGitHubGraphQLRateLimits = /* @__PURE__ */ new Map();
+function normalizeProjectItem(projectId, item, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, priority = {}, rateLimits = null) {
+  if (item.content?.__typename !== "Issue") {
+    return null;
+  }
+  const fieldValues = extractFieldValues(item.fieldValues?.nodes ?? []);
+  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
+  const repository = item.content.repository;
+  const blockedBy = (item.content.blockedBy?.nodes ?? []).flatMap(
+    (node) => node ? [
+      {
+        id: node.id,
+        identifier: `${node.repository.owner.login}/${node.repository.name}#${node.number}`,
+        state: normalizeBlockerState(node.state, lifecycle)
+      }
+    ] : []
+  );
+  const issueUpdatedAtMs = parseTimestampMs(item.content.updatedAt);
+  const itemUpdatedAtMs = parseTimestampMs(item.updatedAt);
+  const trackedUpdatedAt = itemUpdatedAtMs !== null && (issueUpdatedAtMs === null || itemUpdatedAtMs > issueUpdatedAtMs) ? item.updatedAt : item.content.updatedAt ?? item.updatedAt;
+  return {
+    id: item.content.id,
+    identifier: `${repository.owner.login}/${repository.name}#${item.content.number}`,
+    number: item.content.number,
+    title: item.content.title,
+    description: item.content.body,
+    priority: resolvePriority(item, priority),
+    state,
+    branchName: null,
+    url: item.content.url,
+    labels: (item.content.labels?.nodes ?? []).flatMap((label) => label?.name ? [label.name.toLowerCase()] : []).sort(),
+    blockedBy,
+    createdAt: item.content.createdAt,
+    updatedAt: trackedUpdatedAt,
+    repository: {
+      owner: repository.owner.login,
+      name: repository.name,
+      url: repository.url,
+      cloneUrl: deriveCloneUrl(repository.url)
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: projectId,
+      itemId: item.id
+    },
+    metadata: fieldValues,
+    rateLimits
+  };
+}
+async function fetchProjectIssues(config, fetchImpl = fetch) {
+  const issues = [];
+  let cursor = null;
+  const priorityOptionIds = config.priorityFieldName ? await fetchPriorityOptionOrder(
+    config,
+    config.priorityFieldName,
+    fetchImpl
+  ) : void 0;
+  const currentUserLogin = config.assignedOnly ? await fetchCurrentUserLogin(config, fetchImpl) : null;
+  let excludedCount = 0;
+  let latestRateLimits = null;
+  do {
+    const pageResult = await fetchProjectItemsPage(config, cursor, fetchImpl);
+    const page = pageResult.page;
+    latestRateLimits = pageResult.rateLimits ?? latestRateLimits;
+    const pageIssues = (page.nodes ?? []).flatMap((item) => {
+      if (!item) {
+        return [];
+      }
+      const normalized = normalizeProjectItem(
+        config.projectId,
+        item,
+        config.lifecycle,
+        {
+          fieldName: config.priorityFieldName,
+          optionIds: priorityOptionIds
+        },
+        latestRateLimits
+      );
+      if (!normalized) {
+        return [];
+      }
+      if (currentUserLogin && !isIssueAssignedToLogin(item, currentUserLogin)) {
+        excludedCount += 1;
+        return [];
+      }
+      return [normalized];
+    });
+    issues.push(...pageIssues);
+    cursor = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
+  } while (cursor);
+  if (currentUserLogin) {
+    emitAssignedOnlyFilterEvent({
+      projectId: config.projectId,
+      currentUserLogin,
+      includedCount: issues.length,
+      excludedCount
+    });
+  }
+  if (latestRateLimits) {
+    for (const issue of issues) {
+      issue.rateLimits = latestRateLimits;
+    }
+  }
+  return issues;
+}
+async function fetchIssueStatesByIds(config, issueIds, fetchImpl = fetch) {
+  if (issueIds.length === 0) {
+    return [];
+  }
+  const issues = [];
+  for (const issueIdBatch of chunkValues([...new Set(issueIds)], 100)) {
+    const result = await executeGraphQLQueryWithMetadata(
+      config,
+      ISSUE_STATES_BY_IDS_QUERY,
+      {
+        issueIds: issueIdBatch
+      },
+      fetchImpl
+    );
+    const data = result.data;
+    const rateLimits = result.rateLimits;
+    for (const node of data.nodes ?? []) {
+      const projectItem = await resolveIssueProjectItemForStateLookup(
+        config,
+        node,
+        fetchImpl
+      );
+      const normalized = normalizeIssueStateLookupNode(
+        config.projectId,
+        node,
+        projectItem,
+        config.lifecycle,
+        rateLimits
+      );
+      if (normalized) {
+        issues.push(normalized);
+      }
+    }
+  }
+  return issues;
+}
+async function fetchProjectIssueByRepositoryAndNumber(config, repository, issueNumber, fetchImpl = fetch) {
+  const priorityOptionIds = config.priorityFieldName ? await fetchPriorityOptionOrder(
+    config,
+    config.priorityFieldName,
+    fetchImpl
+  ) : void 0;
+  const result = await executeGraphQLQueryWithMetadata(
+    config,
+    REPOSITORY_ISSUE_QUERY,
+    {
+      owner: repository.owner,
+      name: repository.name,
+      issueNumber
+    },
+    fetchImpl
+  );
+  const issue = result.data.repository?.issue ?? null;
+  if (!issue) {
+    return null;
+  }
+  const projectItem = await resolveIssueProjectItemForStateLookup(
+    config,
+    issue,
+    fetchImpl
+  );
+  if (!projectItem) {
+    return null;
+  }
+  return normalizeRepositoryIssueLookup(
+    config.projectId,
+    issue,
+    projectItem,
+    config.lifecycle,
+    {
+      fieldName: config.priorityFieldName,
+      optionIds: priorityOptionIds
+    },
+    result.rateLimits
+  );
+}
+async function fetchProjectItemsPage(config, cursor, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(
+    config,
+    PROJECT_ITEMS_QUERY,
+    {
+      projectId: config.projectId,
+      cursor,
+      pageSize: config.pageSize ?? DEFAULT_PAGE_SIZE
+    },
+    fetchImpl
+  );
+  const data = result.data;
+  const items = data.node?.items;
+  if (!items) {
+    throw new GitHubTrackerQueryError(
+      "GitHub GraphQL response did not include project items."
+    );
+  }
+  return {
+    page: items,
+    rateLimits: result.rateLimits
+  };
+}
+var fetchGithubProjectIssues = fetchProjectIssues;
+var fetchGithubIssueStatesByIds = fetchIssueStatesByIds;
+var fetchGithubProjectIssueByRepositoryAndNumber = fetchProjectIssueByRepositoryAndNumber;
+async function fetchCurrentUserLogin(config, fetchImpl) {
+  const response = await fetchImpl(resolveRestUserApiUrl(config.apiUrl), {
+    method: "GET",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      "user-agent": "gh-symphony",
+      accept: "application/vnd.github+json"
+    },
+    signal: buildRequestSignal(config.timeoutMs)
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new GitHubTrackerHttpError(
+      `GitHub REST request failed with status ${response.status}`,
+      response.status,
+      details
+    );
+  }
+  const payload = await response.json();
+  if (!payload.login) {
+    throw new GitHubTrackerQueryError(
+      "GitHub REST response did not include the authenticated user login."
+    );
+  }
+  return payload.login;
+}
+function isIssueAssignedToLogin(item, login) {
+  if (item.content?.__typename !== "Issue") {
+    return false;
+  }
+  return (item.content.assignees?.nodes ?? []).some(
+    (assignee) => assignee?.login === login
+  );
+}
+function emitAssignedOnlyFilterEvent(input) {
+  console.info(
+    JSON.stringify({
+      event: "tracker-assigned-only-filtered",
+      projectId: input.projectId,
+      currentUserLogin: input.currentUserLogin,
+      includedCount: input.includedCount,
+      excludedCount: input.excludedCount
+    })
+  );
+}
+function extractFieldValues(nodes) {
+  return nodes.reduce((values, node) => {
+    const fieldName = node?.field?.name;
+    if (!fieldName) {
+      return values;
+    }
+    if (node.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.name) {
+      values[fieldName] = node.name;
+    }
+    if (node.__typename === "ProjectV2ItemFieldTextValue" && node.text) {
+      values[fieldName] = node.text;
+    }
+    return values;
+  }, {});
+}
+function normalizeIssueStateLookupNode(projectId, issue, projectItem, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, rateLimits = null) {
+  if (issue?.__typename !== "Issue") {
+    return null;
+  }
+  if (!projectItem) {
+    return null;
+  }
+  const fieldValues = extractFieldValues(projectItem.fieldValues?.nodes ?? []);
+  const state = fieldValues[lifecycle.stateFieldName] ?? "Unknown";
+  const repository = issue.repository;
+  const identifier = `${repository.owner.login}/${repository.name}#${issue.number}`;
+  return {
+    id: issue.id,
+    identifier,
+    number: issue.number,
+    title: identifier,
+    description: null,
+    priority: null,
+    state,
+    branchName: null,
+    url: `${repository.url}/issues/${issue.number}`,
+    labels: [],
+    blockedBy: [],
+    createdAt: null,
+    updatedAt: projectItem.updatedAt ?? issue.updatedAt,
+    repository: {
+      owner: repository.owner.login,
+      name: repository.name,
+      url: repository.url,
+      cloneUrl: deriveCloneUrl(repository.url)
+    },
+    tracker: {
+      adapter: "github-project",
+      bindingId: projectId,
+      itemId: projectItem.id
+    },
+    metadata: fieldValues,
+    rateLimits
+  };
+}
+function normalizeRepositoryIssueLookup(projectId, issue, projectItem, lifecycle = DEFAULT_WORKFLOW_LIFECYCLE, priority = {}, rateLimits = null) {
+  if (!issue || !projectItem) {
+    return null;
+  }
+  return normalizeProjectItem(
+    projectId,
+    {
+      id: projectItem.id,
+      updatedAt: projectItem.updatedAt,
+      fieldValues: projectItem.fieldValues,
+      content: issue
+    },
+    lifecycle,
+    priority,
+    rateLimits
+  );
+}
+async function resolveIssueProjectItemForStateLookup(config, issue, fetchImpl) {
+  if (issue?.__typename !== "Issue") {
+    return null;
+  }
+  let connection = issue.projectItems;
+  let projectItem = findProjectItemByProjectId(
+    connection?.nodes ?? [],
+    config.projectId
+  );
+  let cursor = connection?.pageInfo.endCursor ?? null;
+  while (!projectItem && connection?.pageInfo.hasNextPage) {
+    const nextPage = await fetchIssueProjectItemsPage(
+      config,
+      issue.id,
+      cursor,
+      fetchImpl
+    );
+    projectItem = findProjectItemByProjectId(
+      nextPage.nodes ?? [],
+      config.projectId
+    );
+    connection = nextPage;
+    cursor = nextPage.pageInfo.endCursor;
+  }
+  return projectItem;
+}
+async function fetchIssueProjectItemsPage(config, issueId, cursor, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(
+    config,
+    ISSUE_PROJECT_ITEMS_PAGE_QUERY,
+    {
+      issueId,
+      cursor
+    },
+    fetchImpl
+  );
+  const data = result.data;
+  const issue = data.node;
+  if (issue?.__typename !== "Issue" || !issue.projectItems) {
+    throw new GitHubTrackerQueryError(
+      "GitHub GraphQL response did not include issue project items."
+    );
+  }
+  return issue.projectItems;
+}
+function findProjectItemByProjectId(nodes, projectId) {
+  return nodes.find((item) => item?.project?.id === projectId) ?? null;
+}
+function resolvePriority(item, priority) {
+  if (!priority.fieldName || !priority.optionIds) {
+    return null;
+  }
+  for (const node of item.fieldValues?.nodes ?? []) {
+    if (node?.__typename === "ProjectV2ItemFieldSingleSelectValue" && node.field?.name === priority.fieldName && node.optionId) {
+      return priority.optionIds[node.optionId] ?? null;
+    }
+  }
+  return null;
+}
+function extractPriorityOptionOrder(fields, priorityFieldName) {
+  for (const field of fields) {
+    if (isSingleSelectProjectField(field) && field.name === priorityFieldName) {
+      let nextPriority = 0;
+      const optionEntries = (field.options ?? []).flatMap((option) => {
+        if (!option?.id) {
+          return [];
+        }
+        const entry = [option.id, nextPriority];
+        nextPriority += 1;
+        return [entry];
+      });
+      return Object.fromEntries(optionEntries);
+    }
+  }
+  return void 0;
+}
+async function fetchPriorityOptionOrder(config, priorityFieldName, fetchImpl) {
+  const data = await executeGraphQLQuery(
+    config,
+    PROJECT_FIELDS_QUERY,
+    { projectId: config.projectId },
+    fetchImpl
+  );
+  return extractPriorityOptionOrder(
+    data.node?.fields?.nodes ?? [],
+    priorityFieldName
+  );
+}
+function isSingleSelectProjectField(field) {
+  return field?.__typename === "ProjectV2SingleSelectField";
+}
+function deriveCloneUrl(repositoryUrl) {
+  if (repositoryUrl.startsWith("file://") || repositoryUrl.endsWith(".git")) {
+    return repositoryUrl;
+  }
+  return `${repositoryUrl}.git`;
+}
+function normalizeBlockerState(state, lifecycle) {
+  if (!state) {
+    return null;
+  }
+  const normalized = state.trim().toLowerCase();
+  if (normalized === "closed") {
+    return lifecycle.terminalStates[0] ?? state;
+  }
+  if (normalized === "open") {
+    return null;
+  }
+  return state;
+}
+function resolveRestUserApiUrl(apiUrl) {
+  const parsed = new URL(apiUrl ?? DEFAULT_API_URL);
+  const pathSegments = parsed.pathname.split("/").filter(Boolean);
+  if (pathSegments.at(-1) === "graphql") {
+    pathSegments.pop();
+  }
+  parsed.pathname = `/${pathSegments.join("/")}/user`.replace(/\/{2,}/g, "/");
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString();
+}
+function chunkValues(values, size) {
+  const chunks = [];
+  for (let index = 0; index < values.length; index += size) {
+    chunks.push(values.slice(index, index + size));
+  }
+  return chunks;
+}
+function buildRequestSignal(timeoutMs) {
+  return AbortSignal.timeout(resolveNetworkTimeoutMs(timeoutMs));
+}
+function resolveNetworkTimeoutMs(timeoutMs) {
+  if (timeoutMs !== void 0 && Number.isInteger(timeoutMs) && timeoutMs > 0) {
+    return timeoutMs;
+  }
+  return DEFAULT_NETWORK_TIMEOUT_MS;
+}
+async function executeGraphQLQuery(config, query, variables, fetchImpl) {
+  const result = await executeGraphQLQueryWithMetadata(
+    config,
+    query,
+    variables,
+    fetchImpl
+  );
+  return result.data;
+}
+async function executeGraphQLQueryWithMetadata(config, query, variables, fetchImpl) {
+  const tokenFingerprint = fingerprintToken(config.token);
+  await guardGraphQLRateLimit(tokenFingerprint);
+  const response = await fetchImpl(config.apiUrl ?? DEFAULT_API_URL, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.token}`
+    },
+    body: JSON.stringify({
+      query,
+      variables
+    }),
+    signal: buildRequestSignal(config.timeoutMs)
+  });
+  if (!response.ok) {
+    const details = await response.text();
+    throw new GitHubTrackerHttpError(
+      `GitHub GraphQL request failed with status ${response.status}`,
+      response.status,
+      details
+    );
+  }
+  const payload = await response.json();
+  if (payload.errors?.length) {
+    throw new GitHubTrackerQueryError(
+      payload.errors.map((error) => error.message).join("; ")
+    );
+  }
+  if (!payload.data) {
+    throw new GitHubTrackerQueryError(
+      "GitHub GraphQL response did not include data."
+    );
+  }
+  const data = payload.data;
+  const rateLimits = extractGitHubRateLimits(response.headers);
+  cachedGitHubGraphQLRateLimits.set(tokenFingerprint, rateLimits);
+  return {
+    data,
+    rateLimits
+  };
+}
+async function guardGraphQLRateLimit(tokenFingerprint) {
+  const rateLimit = cachedGitHubGraphQLRateLimits.get(tokenFingerprint) ?? null;
+  if (!rateLimit) {
+    return;
+  }
+  const remaining = rateLimit.remaining;
+  if (remaining === null || remaining > RATE_LIMIT_THRESHOLD) {
+    return;
+  }
+  const resetAtMs = parseTimestampMs(rateLimit.resetAt);
+  if (resetAtMs === null) {
+    throw new GitHubTrackerError("Rate limit near exhaustion");
+  }
+  const waitMs = Math.max(0, resetAtMs - Date.now());
+  if (waitMs > MAX_RATE_LIMIT_WAIT_MS) {
+    throw new GitHubTrackerError("Rate limit near exhaustion");
+  }
+  cachedGitHubGraphQLRateLimits.delete(tokenFingerprint);
+  if (waitMs > 0) {
+    await sleep(waitMs);
+  }
+}
+function fingerprintToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+function extractGitHubRateLimits(headers) {
+  if (!headers || typeof headers.get !== "function") {
+    return null;
+  }
+  const limit = parseIntegerHeader(headers.get("x-ratelimit-limit"));
+  const remaining = parseIntegerHeader(headers.get("x-ratelimit-remaining"));
+  const used = parseIntegerHeader(headers.get("x-ratelimit-used"));
+  const reset = parseIntegerHeader(headers.get("x-ratelimit-reset"));
+  const resource = headers.get("x-ratelimit-resource");
+  if (limit === null && remaining === null && used === null && reset === null && resource === null) {
+    return null;
+  }
+  return {
+    source: "github",
+    limit,
+    remaining,
+    used,
+    reset,
+    resetAt: reset === null ? null : new Date(reset * 1e3).toISOString(),
+    resource
+  };
+}
+function parseIntegerHeader(value) {
+  if (value === null) {
+    return null;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseTimestampMs(value) {
+  if (!value) {
+    return null;
+  }
+  const timestampMs = Date.parse(value);
+  return Number.isFinite(timestampMs) ? timestampMs : null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var PROJECT_ITEMS_QUERY = `
+  query ProjectItems($projectId: ID!, $cursor: String, $pageSize: Int!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        items(first: $pageSize, after: $cursor) {
+          nodes {
+            id
+            updatedAt
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+            content {
+              __typename
+              ... on Issue {
+                id
+                number
+                title
+                body
+                url
+                createdAt
+                updatedAt
+                labels(first: 20) {
+                  nodes {
+                    name
+                  }
+                }
+                assignees(first: 20) {
+                  nodes {
+                    login
+                  }
+                }
+                repository {
+                  name
+                  url
+                  owner {
+                    login
+                  }
+                }
+                blockedBy(first: 100) {
+                  nodes {
+                    id
+                    number
+                    state
+                    repository {
+                      name
+                      owner {
+                        login
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var PROJECT_FIELDS_QUERY = `
+  query ProjectFields($projectId: ID!) {
+    node(id: $projectId) {
+      __typename
+      ... on ProjectV2 {
+        fields(first: 100) {
+          nodes {
+            __typename
+            ... on ProjectV2SingleSelectField {
+              name
+              options {
+                id
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_STATES_BY_IDS_QUERY = `
+  query IssueStatesByIds($issueIds: [ID!]!) {
+    nodes(ids: $issueIds) {
+      __typename
+      ... on Issue {
+        id
+        number
+        updatedAt
+        repository {
+          name
+          url
+          owner {
+            login
+          }
+        }
+        projectItems(first: 100, includeArchived: false) {
+          nodes {
+            id
+            updatedAt
+            project {
+              id
+            }
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var ISSUE_PROJECT_ITEMS_PAGE_QUERY = `
+  query IssueProjectItemsPage($issueId: ID!, $cursor: String) {
+    node(id: $issueId) {
+      __typename
+      ... on Issue {
+        id
+        number
+        updatedAt
+        repository {
+          name
+          url
+          owner {
+            login
+          }
+        }
+        projectItems(first: 100, after: $cursor, includeArchived: false) {
+          nodes {
+            id
+            updatedAt
+            project {
+              id
+            }
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+var REPOSITORY_ISSUE_QUERY = `
+  query RepositoryIssue(
+    $owner: String!
+    $name: String!
+    $issueNumber: Int!
+  ) {
+    repository(owner: $owner, name: $name) {
+      issue(number: $issueNumber) {
+        __typename
+        id
+        number
+        title
+        body
+        url
+        createdAt
+        updatedAt
+        labels(first: 20) {
+          nodes {
+            name
+          }
+        }
+        assignees(first: 20) {
+          nodes {
+            login
+          }
+        }
+        repository {
+          name
+          url
+          owner {
+            login
+          }
+        }
+        blockedBy(first: 100) {
+          nodes {
+            id
+            number
+            state
+            repository {
+              name
+              owner {
+                login
+              }
+            }
+          }
+        }
+        projectItems(first: 20, includeArchived: false) {
+          nodes {
+            id
+            updatedAt
+            project {
+              id
+            }
+            fieldValues(first: 20) {
+              nodes {
+                __typename
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                  field {
+                    ... on ProjectV2SingleSelectField {
+                      name
+                    }
+                  }
+                }
+                ... on ProjectV2ItemFieldTextValue {
+                  text
+                  field {
+                    ... on ProjectV2FieldCommon {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }
+`;
+
+// ../tracker-github/src/orchestrator-adapter.ts
+import { createHash as createHash2 } from "crypto";
+var githubProjectTrackerAdapter = {
+  async listIssues(project, dependencies = {}) {
+    return listProjectIssues(project, dependencies);
+  },
+  async listIssuesByStates(project, states, dependencies = {}) {
+    if (states.length === 0) {
+      return [];
+    }
+    const issues = await listProjectIssues(project, dependencies);
+    const normalizedStates = new Set(
+      states.map((state) => state.trim().toLowerCase())
+    );
+    return issues.filter(
+      (issue) => normalizedStates.has(issue.state.trim().toLowerCase())
+    );
+  },
+  async fetchIssueStatesByIds(project, issueIds, dependencies = {}) {
+    if (issueIds.length === 0) {
+      return [];
+    }
+    return fetchProjectIssueStatesByIds(project, issueIds, dependencies);
+  },
+  buildWorkerEnvironment(project) {
+    return {
+      GITHUB_PROJECT_ID: requireTrackerSetting(project.tracker, "projectId")
+    };
+  },
+  reviveIssue(project, run) {
+    return {
+      id: run.issueId,
+      identifier: run.issueIdentifier,
+      number: parseIssueNumber(run.issueIdentifier),
+      title: run.issueTitle ?? run.issueIdentifier,
+      description: null,
+      priority: null,
+      state: run.issueState,
+      branchName: null,
+      url: null,
+      labels: [],
+      blockedBy: [],
+      createdAt: null,
+      updatedAt: null,
+      repository: run.repository,
+      tracker: {
+        adapter: "github-project",
+        bindingId: project.tracker.bindingId,
+        itemId: run.issueId
+      },
+      metadata: {}
+    };
+  }
+};
+async function listProjectIssues(project, dependencies = {}) {
+  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
+  const loadProjectIssues = () => fetchGithubProjectIssues(trackerConfig, dependencies.fetchImpl);
+  return dependencies.projectItemsCache?.getOrLoad(
+    buildProjectItemsCacheKey(trackerConfig, dependencies),
+    loadProjectIssues
+  ) ?? loadProjectIssues();
+}
+async function fetchProjectIssueStatesByIds(project, issueIds, dependencies = {}) {
+  const trackerConfig = resolveGitHubTrackerConfig(project, dependencies);
+  return fetchGithubIssueStatesByIds(
+    trackerConfig,
+    [...issueIds],
+    dependencies.fetchImpl
+  );
+}
+function resolveGitHubTrackerConfig(project, dependencies = {}) {
+  const token = dependencies.token ?? process.env.GITHUB_GRAPHQL_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GITHUB_GRAPHQL_TOKEN environment variable is required. Run 'gh auth token' or set the variable."
+    );
+  }
+  const githubProjectId = requireTrackerSetting(project.tracker, "projectId");
+  return {
+    projectId: githubProjectId,
+    token,
+    apiUrl: project.tracker.apiUrl,
+    assignedOnly: readBooleanTrackerSetting(project.tracker, "assignedOnly"),
+    priorityFieldName: readOptionalStringTrackerSetting(
+      project.tracker,
+      "priorityFieldName"
+    ),
+    timeoutMs: readNumberTrackerSetting(project.tracker, "timeoutMs")
+  };
+}
+function buildProjectItemsCacheKey(config, _dependencies) {
+  return JSON.stringify({
+    adapter: "github-project",
+    apiUrl: config.apiUrl,
+    assignedOnly: config.assignedOnly ?? false,
+    priorityFieldName: config.priorityFieldName ?? null,
+    projectId: config.projectId,
+    timeoutMs: config.timeoutMs,
+    tokenFingerprint: hashToken(config.token)
+  });
+}
+function hashToken(token) {
+  if (!token) {
+    return null;
+  }
+  return createHash2("sha256").update(token).digest("hex");
+}
+var trackerAdapters = {
+  "github-project": githubProjectTrackerAdapter
+};
+function resolveTrackerAdapter(tracker) {
+  const adapter = trackerAdapters[tracker.adapter];
+  if (!adapter) {
+    throw new Error(`Unsupported tracker adapter: ${tracker.adapter}`);
+  }
+  return adapter;
+}
+function requireTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(
+      `Tracker adapter "${tracker.adapter}" requires the "${key}" setting.`
+    );
+  }
+  return value;
+}
+function readBooleanTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  return value === true || value === "true";
+}
+function readNumberTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  throw new Error(
+    `Tracker adapter "${tracker.adapter}" requires the "${key}" setting to be a positive integer when provided.`
+  );
+}
+function readOptionalStringTrackerSetting(tracker, key) {
+  const value = tracker.settings?.[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parseIssueNumber(identifier) {
+  const match = identifier.match(/#(\d+)$/);
+  return match ? Number.parseInt(match[1] ?? "0", 10) : 0;
+}
+
+export {
+  fetchGithubProjectIssueByRepositoryAndNumber,
+  resolveTrackerAdapter
+};