@hcrosse/opencode-pr-tracker 0.2.0 → 0.3.0

package/dist/server.js

@@ -1555,36 +1555,40 @@ var require_proper_lockfile = __commonJS((exports, module) => {
 // src/server.ts
 import { tool } from "@opencode-ai/plugin";
 
-// src/state.ts
-var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { createHash, randomUUID } from "crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
+// src/github.ts
+import { execFile } from "child_process";
+
+// src/exhaustive.ts
+function casesHandled(value) {
+  throw new Error(`Unhandled case: ${String(value)}`);
+}
 
 // src/url.ts
+var expectedPullRequestUrl = "Expected https://github.com/<owner>/<repository>/pull/<positive-integer> or github.com/<owner>/<repository>/pull/<positive-integer>";
 var invalidPullRequestUrl = {
   ok: false,
   error: {
     tag: "InvalidPullRequestUrl",
-    message: "Expected https://github.com/<owner>/<repository>/pull/<positive-integer>"
+    message: expectedPullRequestUrl
   }
 };
 var segmentPattern = /^[A-Za-z0-9._-]+$/;
+var schemeLessPrefix = "github.com/";
 function parsePullRequestUrl(input) {
-  if (input.trim() !== input)
+  if (/\s/.test(input))
     return invalidPullRequestUrl;
   if (input.includes("\\"))
     return invalidPullRequestUrl;
-  if (!input.startsWith("https://"))
+  const candidate = input.slice(0, schemeLessPrefix.length).toLowerCase() === schemeLessPrefix ? `https://${input}` : input;
+  if (!candidate.startsWith("https://"))
     return invalidPullRequestUrl;
-  const authorityEnd = input.indexOf("/", "https://".length);
+  const authorityEnd = candidate.indexOf("/", "https://".length);
   if (authorityEnd === -1)
     return invalidPullRequestUrl;
-  if (input.slice("https://".length, authorityEnd).toLowerCase() !== "github.com") {
+  if (candidate.slice("https://".length, authorityEnd).toLowerCase() !== "github.com") {
     return invalidPullRequestUrl;
   }
-  const rawPath = input.slice(authorityEnd).split(/[?#]/, 1).join("");
+  const rawPath = candidate.slice(authorityEnd).split(/[?#]/, 1).join("");
   for (const segment of rawPath.split("/")) {
     let decoded;
     try {
@@ -1597,7 +1601,7 @@ function parsePullRequestUrl(input) {
   }
   let parsed;
   try {
-    parsed = new URL(input);
+    parsed = new URL(candidate);
   } catch {
     return invalidPullRequestUrl;
   }
@@ -1627,7 +1631,914 @@ function formatPullRequestRef(pullRequest) {
   return `${pullRequest.owner}/${pullRequest.repository}#${pullRequest.number}`;
 }
 
+// src/github.ts
+var invalidGitHubResponse = {
+  ok: false,
+  error: {
+    tag: "InvalidGitHubResponse",
+    message: "GitHub returned an invalid pull request response"
+  }
+};
+var pullRequestNotFound = {
+  ok: false,
+  error: {
+    tag: "PullRequestNotFound",
+    message: "Pull request does not exist or is not accessible"
+  }
+};
+var githubBatchLimitExceeded = {
+  ok: false,
+  error: {
+    tag: "GitHubBatchLimitExceeded",
+    limit: 20,
+    message: "GitHub batch cannot contain more than 20 pull requests"
+  }
+};
+var maximumPullRequestsPerBatch = 20;
+var maximumCheckContextsPerPage = 100;
+var statusContextOnlyFields = ["context", "state", "createdAt"];
+var checkRunOnlyFields = ["name", "status", "conclusion", "checkSuite"];
+var checkContextSelection = `nodes { __typename ... on StatusContext { id context state createdAt } ... on CheckRun { id name status conclusion checkSuite { id createdAt app { id } workflowRun { event runNumber runAttempt workflow { id } } } } } totalCount pageInfo { hasNextPage endCursor }`;
+var pullRequestSelection = `__typename ... on PullRequest { title state url mergedAt mergeable mergeStateStatus baseRef { branchProtectionRule { requiresStatusChecks requiresStrictStatusChecks } refUpdateRule { requiredStatusCheckContexts } rules(first: 100) { nodes { parameters { __typename ... on RequiredStatusChecksParameters { strictRequiredStatusChecksPolicy requiredStatusChecks { context } } } } totalCount pageInfo { hasNextPage } } } statusCheckRollup { contexts(first: ${maximumCheckContextsPerPage}) { ${checkContextSelection} } } }`;
+var continuationQuery = `query PullRequestContexts($url: URI!, $cursor: String!) { resource(url: $url) { __typename ... on PullRequest { url statusCheckRollup { contexts(first: ${maximumCheckContextsPerPage}, after: $cursor) { ${checkContextSelection} } } } } }`;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseProcessExecutionFailed(value) {
+  if (!isRecord(value) || value.tag !== "ProcessExecutionFailed" || value.code !== null && typeof value.code !== "string" && typeof value.code !== "number" || typeof value.stderr !== "string" || typeof value.stdout !== "string" || !("cause" in value)) {
+    return;
+  }
+  return {
+    tag: "ProcessExecutionFailed",
+    code: value.code,
+    stderr: value.stderr,
+    stdout: value.stdout,
+    cause: value.cause
+  };
+}
+function parseNonBlankString(input) {
+  return typeof input === "string" && input.trim() !== "" ? input : undefined;
+}
+function parseDate(input) {
+  if (typeof input !== "string")
+    return;
+  const match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(?:[Zz]|[+-](\d{2}):(\d{2}))$/.exec(input);
+  if (match === null)
+    return;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const hour = Number(match[4]);
+  const minute = Number(match[5]);
+  const second = Number(match[6]);
+  const offsetHour = Number(match[8] ?? 0);
+  const offsetMinute = Number(match[9] ?? 0);
+  const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+  if (daysInMonth === undefined || day < 1 || day > daysInMonth || hour > 23 || minute > 59 || second > 59 || offsetHour > 23 || offsetMinute > 59) {
+    return;
+  }
+  if (Number.isNaN(new Date(input).valueOf()))
+    return;
+  const epochSeconds = new Date(input.replace(/\.\d+/, "")).valueOf() / 1000;
+  if (!Number.isInteger(epochSeconds))
+    return;
+  return {
+    epochSeconds,
+    fractionalSeconds: (match[7] ?? "").replace(/0+$/, "")
+  };
+}
+function compareTimestamps(left, right) {
+  if (left.epochSeconds < right.epochSeconds)
+    return -1;
+  if (left.epochSeconds > right.epochSeconds)
+    return 1;
+  const width = Math.max(left.fractionalSeconds.length, right.fractionalSeconds.length);
+  const leftFraction = left.fractionalSeconds.padEnd(width, "0");
+  const rightFraction = right.fractionalSeconds.padEnd(width, "0");
+  if (leftFraction < rightFraction)
+    return -1;
+  if (leftFraction > rightFraction)
+    return 1;
+  return 0;
+}
+function parseStatusContextState(input) {
+  switch (input) {
+    case "EXPECTED":
+    case "PENDING":
+    case "SUCCESS":
+    case "ERROR":
+    case "FAILURE":
+      return input;
+    default:
+      return;
+  }
+}
+function parseCheckRunStatus(input) {
+  switch (input) {
+    case "REQUESTED":
+    case "QUEUED":
+    case "IN_PROGRESS":
+    case "COMPLETED":
+    case "WAITING":
+    case "PENDING":
+      return input;
+    default:
+      return;
+  }
+}
+function parseCheckRunConclusion(input) {
+  switch (input) {
+    case null:
+    case "SUCCESS":
+    case "FAILURE":
+    case "CANCELLED":
+    case "TIMED_OUT":
+    case "ACTION_REQUIRED":
+    case "STARTUP_FAILURE":
+    case "STALE":
+    case "NEUTRAL":
+    case "SKIPPED":
+      return input;
+    default:
+      return;
+  }
+}
+function parseStatusContext(input) {
+  const id = parseNonBlankString(input.id);
+  const context = parseNonBlankString(input.context);
+  const state = parseStatusContextState(input.state);
+  const createdAt = parseDate(input.createdAt);
+  if (id === undefined || context === undefined || state === undefined || createdAt === undefined) {
+    return invalidGitHubResponse;
+  }
+  return { ok: true, value: { tag: "StatusContext", id, context, state, createdAt } };
+}
+function parseCheckRun(input) {
+  const id = parseNonBlankString(input.id);
+  const name = parseNonBlankString(input.name);
+  const status = parseCheckRunStatus(input.status);
+  const conclusion = parseCheckRunConclusion(input.conclusion);
+  if (id === undefined || name === undefined || status === undefined || conclusion === undefined || status !== "COMPLETED" && conclusion !== null || !isRecord(input.checkSuite)) {
+    return invalidGitHubResponse;
+  }
+  const suiteId = parseNonBlankString(input.checkSuite.id);
+  const suiteCreatedAt = parseDate(input.checkSuite.createdAt);
+  if (suiteId === undefined || suiteCreatedAt === undefined)
+    return invalidGitHubResponse;
+  let sourceIdentity;
+  if (input.checkSuite.app === null) {
+    sourceIdentity = ["suite", suiteId];
+  } else {
+    if (!isRecord(input.checkSuite.app))
+      return invalidGitHubResponse;
+    const appId = parseNonBlankString(input.checkSuite.app.id);
+    if (appId === undefined)
+      return invalidGitHubResponse;
+    sourceIdentity = ["app", appId];
+  }
+  let workflowRun;
+  if (input.checkSuite.workflowRun === null) {
+    workflowRun = undefined;
+  } else {
+    if (!isRecord(input.checkSuite.workflowRun) || !isRecord(input.checkSuite.workflowRun.workflow)) {
+      return invalidGitHubResponse;
+    }
+    const event = parseNonBlankString(input.checkSuite.workflowRun.event);
+    const workflowId = parseNonBlankString(input.checkSuite.workflowRun.workflow.id);
+    const runNumber = input.checkSuite.workflowRun.runNumber;
+    const runAttempt = input.checkSuite.workflowRun.runAttempt;
+    if (event === undefined || workflowId === undefined || !Number.isInteger(runNumber) || Number(runNumber) <= 0 || !Number.isInteger(runAttempt) || Number(runAttempt) <= 0) {
+      return invalidGitHubResponse;
+    }
+    workflowRun = { event, workflowId, runNumber: Number(runNumber), runAttempt: Number(runAttempt) };
+  }
+  return {
+    ok: true,
+    value: { tag: "CheckRun", id, name, status, conclusion, suiteId, suiteCreatedAt, sourceIdentity, workflowRun }
+  };
+}
+function parseCheckContexts(input) {
+  if (!isRecord(input) || !Number.isInteger(input.totalCount) || Number(input.totalCount) < 0 || !isRecord(input.pageInfo) || typeof input.pageInfo.hasNextPage !== "boolean" || input.pageInfo.endCursor !== null && typeof input.pageInfo.endCursor !== "string") {
+    return invalidGitHubResponse;
+  }
+  const nodes = input.nodes === null && input.totalCount === 0 ? [] : input.nodes;
+  if (!Array.isArray(nodes) || nodes.length > maximumCheckContextsPerPage || nodes.length > Number(input.totalCount)) {
+    return invalidGitHubResponse;
+  }
+  const contexts = [];
+  const ids = new Set;
+  for (const node of nodes) {
+    if (!isRecord(node))
+      return invalidGitHubResponse;
+    let parsed;
+    switch (node.__typename) {
+      case "StatusContext":
+        if (checkRunOnlyFields.some((field) => (field in node)))
+          return invalidGitHubResponse;
+        parsed = parseStatusContext(node);
+        break;
+      case "CheckRun":
+        if (statusContextOnlyFields.some((field) => (field in node)))
+          return invalidGitHubResponse;
+        parsed = parseCheckRun(node);
+        break;
+      default:
+        return invalidGitHubResponse;
+    }
+    if (!parsed.ok || ids.has(parsed.value.id))
+      return invalidGitHubResponse;
+    ids.add(parsed.value.id);
+    contexts.push(parsed.value);
+  }
+  const nextCursor = input.pageInfo.hasNextPage ? parseNonBlankString(input.pageInfo.endCursor) : undefined;
+  if (input.pageInfo.hasNextPage && nextCursor === undefined)
+    return invalidGitHubResponse;
+  if (nextCursor !== undefined && contexts.length === 0)
+    return invalidGitHubResponse;
+  return {
+    ok: true,
+    value: {
+      contexts,
+      totalCount: Number(input.totalCount),
+      ...nextCursor === undefined ? {} : { nextCursor }
+    }
+  };
+}
+function classifyStatusContext(state) {
+  switch (state) {
+    case "ERROR":
+    case "FAILURE":
+      return "failed";
+    case "EXPECTED":
+    case "PENDING":
+      return "pending";
+    case "SUCCESS":
+      return "passed";
+    default:
+      return casesHandled(state);
+  }
+}
+function classifyCheckRun(checkRun) {
+  if (checkRun.status !== "COMPLETED")
+    return "pending";
+  switch (checkRun.conclusion) {
+    case "FAILURE":
+    case "CANCELLED":
+    case "TIMED_OUT":
+    case "ACTION_REQUIRED":
+    case "STARTUP_FAILURE":
+    case "STALE":
+      return "failed";
+    case "SUCCESS":
+      return "passed";
+    case "NEUTRAL":
+    case "SKIPPED":
+    case null:
+      return "ignored";
+    default:
+      return casesHandled(checkRun.conclusion);
+  }
+}
+function classifyContexts(contexts) {
+  const statusContexts = new Map;
+  const workflowChecks = new Map;
+  const nonWorkflowChecks = new Map;
+  for (const context of contexts) {
+    if (context.tag === "StatusContext") {
+      const identity2 = context.context.toLowerCase();
+      const existing2 = statusContexts.get(identity2);
+      const bucket2 = classifyStatusContext(context.state);
+      const ordering2 = existing2 === undefined ? 1 : compareTimestamps(context.createdAt, existing2.createdAt);
+      if (ordering2 > 0) {
+        statusContexts.set(identity2, { createdAt: context.createdAt, buckets: [bucket2] });
+      } else if (ordering2 === 0 && existing2 !== undefined) {
+        existing2.buckets.push(bucket2);
+      }
+      continue;
+    }
+    const bucket = classifyCheckRun(context);
+    if (context.workflowRun !== undefined) {
+      const identity2 = JSON.stringify([
+        "workflow",
+        context.sourceIdentity,
+        context.workflowRun.workflowId,
+        context.workflowRun.event,
+        context.name
+      ]);
+      const existing2 = workflowChecks.get(identity2);
+      const isNewer = existing2 === undefined || context.workflowRun.runNumber > existing2.runNumber || context.workflowRun.runNumber === existing2.runNumber && context.workflowRun.runAttempt > existing2.runAttempt;
+      if (isNewer) {
+        workflowChecks.set(identity2, {
+          runNumber: context.workflowRun.runNumber,
+          runAttempt: context.workflowRun.runAttempt,
+          buckets: [bucket]
+        });
+      } else if (context.workflowRun.runNumber === existing2.runNumber && context.workflowRun.runAttempt === existing2.runAttempt) {
+        existing2.buckets.push(bucket);
+      }
+      continue;
+    }
+    const identity = JSON.stringify(["check", context.sourceIdentity, context.name]);
+    const existing = nonWorkflowChecks.get(identity);
+    const ordering = existing === undefined ? 1 : compareTimestamps(context.suiteCreatedAt, existing.suiteCreatedAt);
+    if (ordering > 0) {
+      nonWorkflowChecks.set(identity, { suiteCreatedAt: context.suiteCreatedAt, buckets: [bucket] });
+    } else if (ordering === 0 && existing !== undefined) {
+      existing.buckets.push(bucket);
+    }
+  }
+  const buckets = new Set;
+  for (const selection of [...statusContexts.values(), ...workflowChecks.values(), ...nonWorkflowChecks.values()]) {
+    for (const bucket of selection.buckets)
+      buckets.add(bucket);
+  }
+  if (buckets.has("failed"))
+    return "failed";
+  if (buckets.has("pending"))
+    return "pending";
+  if (buckets.has("passed"))
+    return "passed";
+  return "none";
+}
+function parseStatusCheckRollup(input) {
+  if (input === null)
+    return { ok: true, value: null };
+  if (!isRecord(input))
+    return invalidGitHubResponse;
+  return parseCheckContexts(input.contexts);
+}
+function samePullRequest(left, right) {
+  return left.number === right.number && left.owner.toLowerCase() === right.owner.toLowerCase() && left.repository.toLowerCase() === right.repository.toLowerCase();
+}
+function parseMergeability(input) {
+  switch (input) {
+    case "MERGEABLE":
+      return { ok: true, value: "mergeable" };
+    case "CONFLICTING":
+      return { ok: true, value: "conflicting" };
+    case "UNKNOWN":
+      return { ok: true, value: "unknown" };
+    default:
+      return invalidGitHubResponse;
+  }
+}
+function parseMergeStateStatus(input) {
+  switch (input) {
+    case "BEHIND":
+      return { ok: true, value: "behind" };
+    case "BLOCKED":
+    case "CLEAN":
+    case "DIRTY":
+    case "DRAFT":
+    case "HAS_HOOKS":
+    case "UNKNOWN":
+    case "UNSTABLE":
+      return { ok: true, value: "other" };
+    default:
+      return invalidGitHubResponse;
+  }
+}
+function parseRequiredStatusChecks(input) {
+  if (!Array.isArray(input))
+    return invalidGitHubResponse;
+  for (const check of input) {
+    if (!isRecord(check) || typeof check.context !== "string" || check.context.trim() === "") {
+      return invalidGitHubResponse;
+    }
+  }
+  return { ok: true, value: input.length > 0 };
+}
+function parseRules(input) {
+  if (!isRecord(input) || !Number.isInteger(input.totalCount) || Number(input.totalCount) < 0 || !isRecord(input.pageInfo) || typeof input.pageInfo.hasNextPage !== "boolean") {
+    return invalidGitHubResponse;
+  }
+  const nodes = input.nodes === null && input.totalCount === 0 ? [] : input.nodes;
+  if (!Array.isArray(nodes) || nodes.length > Number(input.totalCount))
+    return invalidGitHubResponse;
+  if (input.pageInfo.hasNextPage ? nodes.length >= Number(input.totalCount) : nodes.length !== input.totalCount) {
+    return invalidGitHubResponse;
+  }
+  let strict = false;
+  for (const node of nodes) {
+    if (!isRecord(node) || !(node.parameters === null || isRecord(node.parameters))) {
+      return invalidGitHubResponse;
+    }
+    if (node.parameters === null)
+      continue;
+    if (typeof node.parameters.__typename !== "string")
+      return invalidGitHubResponse;
+    if (node.parameters.__typename !== "RequiredStatusChecksParameters")
+      continue;
+    if (typeof node.parameters.strictRequiredStatusChecksPolicy !== "boolean")
+      return invalidGitHubResponse;
+    const requiredChecks = parseRequiredStatusChecks(node.parameters.requiredStatusChecks);
+    if (!requiredChecks.ok)
+      return requiredChecks;
+    if (node.parameters.strictRequiredStatusChecksPolicy && requiredChecks.value)
+      strict = true;
+  }
+  return { ok: true, value: { strict, incomplete: input.pageInfo.hasNextPage } };
+}
+function parseRefUpdateRule(input) {
+  if (input === null)
+    return { ok: true, value: false };
+  if (!isRecord(input))
+    return invalidGitHubResponse;
+  if (input.requiredStatusCheckContexts === null)
+    return { ok: true, value: false };
+  if (!Array.isArray(input.requiredStatusCheckContexts))
+    return invalidGitHubResponse;
+  for (const context of input.requiredStatusCheckContexts) {
+    if (typeof context !== "string" || context.trim() === "")
+      return invalidGitHubResponse;
+  }
+  return { ok: true, value: input.requiredStatusCheckContexts.length > 0 };
+}
+function parseUpdatePolicy(input) {
+  if (input === null)
+    return { ok: true, value: { strict: false, incomplete: false } };
+  if (!isRecord(input))
+    return invalidGitHubResponse;
+  const refUpdateHasRequiredChecks = parseRefUpdateRule(input.refUpdateRule);
+  if (!refUpdateHasRequiredChecks.ok)
+    return refUpdateHasRequiredChecks;
+  let branchProtectionIsStrict = false;
+  if (input.branchProtectionRule !== null) {
+    if (!isRecord(input.branchProtectionRule) || typeof input.branchProtectionRule.requiresStatusChecks !== "boolean" || typeof input.branchProtectionRule.requiresStrictStatusChecks !== "boolean") {
+      return invalidGitHubResponse;
+    }
+    branchProtectionIsStrict = input.branchProtectionRule.requiresStatusChecks && input.branchProtectionRule.requiresStrictStatusChecks;
+  }
+  const rules = parseRules(input.rules);
+  if (!rules.ok)
+    return rules;
+  return {
+    ok: true,
+    value: {
+      strict: branchProtectionIsStrict || rules.value.strict,
+      incomplete: rules.value.incomplete || input.branchProtectionRule === null && refUpdateHasRequiredChecks.value
+    }
+  };
+}
+function parseBlocker(mergeStateStatusInput, baseRefInput) {
+  const mergeStateStatus = parseMergeStateStatus(mergeStateStatusInput);
+  if (!mergeStateStatus.ok)
+    return mergeStateStatus;
+  if (mergeStateStatus.value !== "behind")
+    return { ok: true, value: "none" };
+  const updatePolicy = parseUpdatePolicy(baseRefInput);
+  if (!updatePolicy.ok)
+    return updatePolicy;
+  if (updatePolicy.value.strict)
+    return { ok: true, value: "behind" };
+  return updatePolicy.value.incomplete ? invalidGitHubResponse : { ok: true, value: "none" };
+}
+function parsePullRequestMetadata(input, pullRequest) {
+  if (!isRecord(input) || input.__typename !== "PullRequest" || typeof input.title !== "string" || input.title.trim() === "") {
+    return invalidGitHubResponse;
+  }
+  if (input.state !== "OPEN" && input.state !== "CLOSED" && input.state !== "MERGED") {
+    return invalidGitHubResponse;
+  }
+  if (input.mergedAt !== null && typeof input.mergedAt !== "string")
+    return invalidGitHubResponse;
+  if (typeof input.mergedAt === "string" && Number.isNaN(new Date(input.mergedAt).valueOf())) {
+    return invalidGitHubResponse;
+  }
+  if (input.state === "MERGED" && typeof input.mergedAt !== "string")
+    return invalidGitHubResponse;
+  if (input.state !== "MERGED" && input.mergedAt !== null)
+    return invalidGitHubResponse;
+  if (typeof input.url !== "string")
+    return invalidGitHubResponse;
+  const responseUrl = parsePullRequestUrl(input.url);
+  if (!responseUrl.ok || !samePullRequest(responseUrl.value, pullRequest))
+    return invalidGitHubResponse;
+  const mergeability = parseMergeability(input.mergeable);
+  if (!mergeability.ok)
+    return mergeability;
+  return {
+    ok: true,
+    value: {
+      title: input.title,
+      state: input.state,
+      mergeability: mergeability.value,
+      mergeStateStatus: input.mergeStateStatus,
+      baseRef: input.baseRef
+    }
+  };
+}
+function finalizeResponse(metadata, pullRequest, ci) {
+  let state;
+  switch (metadata.state) {
+    case "OPEN": {
+      let blocker = "none";
+      if (metadata.mergeability !== "conflicting" && (ci === "none" || ci === "passed")) {
+        const parsedBlocker = parseBlocker(metadata.mergeStateStatus, metadata.baseRef);
+        if (!parsedBlocker.ok)
+          return parsedBlocker;
+        blocker = parsedBlocker.value;
+      }
+      state = { tag: "Open", ci, mergeability: metadata.mergeability, blocker };
+      break;
+    }
+    case "MERGED":
+      state = { tag: "Merged" };
+      break;
+    case "CLOSED":
+      state = { tag: "Closed" };
+      break;
+    default:
+      return casesHandled(metadata.state);
+  }
+  return {
+    ok: true,
+    value: {
+      tag: "Available",
+      pullRequest,
+      title: metadata.title,
+      state,
+      stale: false
+    }
+  };
+}
+function parseInitialPullRequest(input, pullRequest) {
+  if (input === null)
+    return pullRequestNotFound;
+  if (!isRecord(input))
+    return invalidGitHubResponse;
+  const contextPage = parseStatusCheckRollup(input.statusCheckRollup);
+  if (!contextPage.ok)
+    return contextPage;
+  if (contextPage.value !== null && contextPage.value.nextCursor === undefined && contextPage.value.contexts.length !== contextPage.value.totalCount) {
+    return invalidGitHubResponse;
+  }
+  const metadata = parsePullRequestMetadata(input, pullRequest);
+  return metadata.ok ? { ok: true, value: { pullRequest, metadata: metadata.value, contextPage: contextPage.value } } : metadata;
+}
+function createBatchQuery(size) {
+  const variables = Array.from({ length: size }, (_, index) => `$url${index}: URI!`).join(", ");
+  const fields = Array.from({ length: size }, (_, index) => `pr${index}: resource(url: $url${index}) { ${pullRequestSelection} }`).join(" ");
+  return `query BatchPullRequests(${variables}) { ${fields} }`;
+}
+function parseGraphqlErrorAliases(input, size) {
+  if (input === undefined)
+    return { ok: true, value: new Set };
+  if (!Array.isArray(input))
+    return invalidGitHubResponse;
+  const aliases = new Set;
+  for (const error of input) {
+    if (!isRecord(error) || typeof error.message !== "string" || !Array.isArray(error.path) || typeof error.path[0] !== "string") {
+      return invalidGitHubResponse;
+    }
+    const match = /^pr([0-9]+)$/.exec(error.path[0]);
+    if (match === null)
+      return invalidGitHubResponse;
+    const index = Number(match[1]);
+    if (!Number.isInteger(index) || index < 0 || index >= size)
+      return invalidGitHubResponse;
+    aliases.add(index);
+  }
+  return { ok: true, value: aliases };
+}
+function parseBatchResponse(input, pullRequests) {
+  if (!isRecord(input) || !isRecord(input.data))
+    return invalidGitHubResponse;
+  const data = input.data;
+  const errorAliases = parseGraphqlErrorAliases(input.errors, pullRequests.length);
+  if (!errorAliases.ok)
+    return errorAliases;
+  return {
+    ok: true,
+    value: pullRequests.map((pullRequest, index) => errorAliases.value.has(index) ? invalidGitHubResponse : parseInitialPullRequest(data[`pr${index}`], pullRequest))
+  };
+}
+function parseContinuationResponse(input, pullRequest) {
+  if (!isRecord(input) || input.errors !== undefined && (!Array.isArray(input.errors) || input.errors.length > 0) || !isRecord(input.data) || !isRecord(input.data.resource)) {
+    return invalidGitHubResponse;
+  }
+  const resource = input.data.resource;
+  if (resource.__typename !== "PullRequest" || typeof resource.url !== "string")
+    return invalidGitHubResponse;
+  const responseUrl = parsePullRequestUrl(resource.url);
+  if (!responseUrl.ok || !samePullRequest(responseUrl.value, pullRequest) || !isRecord(resource.statusCheckRollup)) {
+    return invalidGitHubResponse;
+  }
+  return parseCheckContexts(resource.statusCheckRollup.contexts);
+}
+function isCancellation(cause, signal) {
+  if (signal?.aborted)
+    return true;
+  const originalCause = parseProcessExecutionFailed(cause)?.cause ?? cause;
+  return originalCause instanceof Error && originalCause.name === "AbortError";
+}
+var authenticationFailureMarkers = ["http 401", "bad credentials", "not logged into", "gh auth login"];
+function isAuthenticationFailure(failure) {
+  if (failure.code === 4)
+    return true;
+  const stderr = failure.stderr.toLowerCase();
+  return authenticationFailureMarkers.some((marker) => stderr.includes(marker));
+}
+function classifyProcessFailure(cause) {
+  const failure = parseProcessExecutionFailed(cause);
+  if (failure?.code === "ENOENT") {
+    return { tag: "GitHubCliMissing", message: "GitHub CLI is not installed", cause };
+  }
+  if (failure && isAuthenticationFailure(failure)) {
+    return { tag: "GitHubAuthenticationRequired", message: "GitHub CLI authentication required", cause };
+  }
+  return { tag: "GitHubUnavailable", message: "GitHub status unavailable", cause };
+}
+function processFailureStdout(cause) {
+  if (!isRecord(cause) || typeof cause.stdout !== "string" || cause.stdout.trim() === "")
+    return;
+  return cause.stdout;
+}
+async function runAndDecode(runner, args, options) {
+  let stdout;
+  let processFailure;
+  try {
+    const output = await runner("gh", args, options);
+    stdout = output.stdout;
+  } catch (cause) {
+    if (isCancellation(cause, options.signal)) {
+      return {
+        ok: false,
+        error: {
+          tag: "GitHubCancelled",
+          message: "GitHub status request cancelled",
+          cause
+        }
+      };
+    }
+    processFailure = classifyProcessFailure(cause);
+    const partialStdout = processFailureStdout(cause);
+    if (partialStdout === undefined)
+      return { ok: false, error: processFailure };
+    stdout = partialStdout;
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(stdout);
+  } catch {
+    return processFailure === undefined ? invalidGitHubResponse : { ok: false, error: processFailure };
+  }
+  return { ok: true, value: { decoded, ...processFailure === undefined ? {} : { processFailure } } };
+}
+async function continuePullRequest(runner, initial, options) {
+  if (initial.contextPage?.nextCursor === undefined) {
+    const ci = initial.contextPage === null ? "none" : classifyContexts(initial.contextPage.contexts);
+    return { tag: "Item", result: finalizeResponse(initial.metadata, initial.pullRequest, ci) };
+  }
+  const contexts = [...initial.contextPage.contexts];
+  const totalCount = initial.contextPage.totalCount;
+  const contextIds = new Set(contexts.map((context) => context.id));
+  const cursors = new Set([initial.contextPage.nextCursor]);
+  let cursor = initial.contextPage.nextCursor;
+  while (cursor !== undefined) {
+    const args = [
+      "api",
+      "graphql",
+      "--method",
+      "POST",
+      "-f",
+      `query=${continuationQuery}`,
+      "-f",
+      `url=${initial.pullRequest.url}`,
+      "-f",
+      `cursor=${cursor}`
+    ];
+    const output = await runAndDecode(runner, args, options);
+    if (!output.ok) {
+      return output.error.tag === "GitHubCancelled" ? { tag: "Cancelled", error: output.error } : { tag: "Item", result: { ok: false, error: output.error } };
+    }
+    const page = parseContinuationResponse(output.value.decoded, initial.pullRequest);
+    if (!page.ok) {
+      return {
+        tag: "Item",
+        result: { ok: false, error: output.value.processFailure ?? page.error }
+      };
+    }
+    if (page.value.totalCount !== totalCount)
+      return { tag: "Item", result: invalidGitHubResponse };
+    for (const context of page.value.contexts) {
+      if (contextIds.has(context.id))
+        return { tag: "Item", result: invalidGitHubResponse };
+      contextIds.add(context.id);
+    }
+    if (contexts.length + page.value.contexts.length > totalCount) {
+      return { tag: "Item", result: invalidGitHubResponse };
+    }
+    if (page.value.nextCursor !== undefined) {
+      if (cursors.has(page.value.nextCursor))
+        return { tag: "Item", result: invalidGitHubResponse };
+      cursors.add(page.value.nextCursor);
+    }
+    contexts.push(...page.value.contexts);
+    cursor = page.value.nextCursor;
+  }
+  if (contexts.length !== totalCount)
+    return { tag: "Item", result: invalidGitHubResponse };
+  const status = finalizeResponse(initial.metadata, initial.pullRequest, classifyContexts(contexts));
+  return { tag: "Item", result: status };
+}
+var execFileRunner = (file, args, options) => new Promise((resolve, reject) => {
+  execFile(file, [...args], {
+    encoding: "utf8",
+    ...options.signal ? { signal: options.signal } : {},
+    ...options.cwd ? { cwd: options.cwd } : {}
+  }, (error, stdout, stderr) => {
+    if (error) {
+      reject({
+        tag: "ProcessExecutionFailed",
+        code: error.code ?? null,
+        stderr,
+        stdout,
+        cause: error
+      });
+      return;
+    }
+    resolve({ stdout });
+  });
+});
+function createGitHubClient(runner = execFileRunner) {
+  return {
+    async get(pullRequests, options = {}) {
+      if (pullRequests.length === 0)
+        return { ok: true, value: [] };
+      if (pullRequests.length > maximumPullRequestsPerBatch)
+        return githubBatchLimitExceeded;
+      const query = createBatchQuery(pullRequests.length);
+      const args = ["api", "graphql", "--method", "POST", "-f", `query=${query}`];
+      for (const [index, pullRequest] of pullRequests.entries()) {
+        args.push("-f", `url${index}=${pullRequest.url}`);
+      }
+      const output = await runAndDecode(runner, args, options);
+      if (!output.ok)
+        return output;
+      const parsed = parseBatchResponse(output.value.decoded, pullRequests);
+      if (!parsed.ok)
+        return { ok: false, error: output.value.processFailure ?? parsed.error };
+      const outcomes = await Promise.all(parsed.value.map((item) => {
+        if (!item.ok)
+          return Promise.resolve({ tag: "Item", result: item });
+        return continuePullRequest(runner, item.value, options);
+      }));
+      const batch = [];
+      let cancellation;
+      for (const outcome of outcomes) {
+        if (outcome.tag === "Cancelled")
+          cancellation ??= outcome.error;
+        else
+          batch.push(outcome.result);
+      }
+      return cancellation === undefined ? { ok: true, value: batch } : { ok: false, error: cancellation };
+    }
+  };
+}
+var openAppearances = {
+  passed: { tone: "green", label: "checks passed", strikethrough: false },
+  pending: { tone: "yellow", label: "checks pending", strikethrough: false },
+  failed: { tone: "red", label: "checks failed", strikethrough: false },
+  none: { tone: "gray", label: "no checks", strikethrough: false }
+};
+var diagnosticLabels = {
+  GitHubCliMissing: "install gh",
+  GitHubAuthenticationRequired: "run gh auth login",
+  GitHubUnavailable: "GitHub unavailable",
+  PullRequestNotFound: "not found or inaccessible",
+  InvalidGitHubResponse: "invalid GitHub response"
+};
+function stateAppearance(state) {
+  switch (state.tag) {
+    case "Open": {
+      switch (state.mergeability) {
+        case "conflicting":
+          return { tone: "red", label: "merge conflict", strikethrough: false };
+        case "mergeable":
+        case "unknown":
+          switch (state.ci) {
+            case "failed":
+            case "pending":
+              return openAppearances[state.ci];
+            case "none":
+            case "passed":
+              switch (state.blocker) {
+                case "behind":
+                  return { tone: "yellow", label: "branch behind", strikethrough: false };
+                case "none":
+                  return openAppearances[state.ci];
+                default:
+                  return casesHandled(state.blocker);
+              }
+            default:
+              return casesHandled(state.ci);
+          }
+        default:
+          return casesHandled(state.mergeability);
+      }
+    }
+    case "Merged":
+      return { tone: "purple", label: "merged", strikethrough: true };
+    case "Closed":
+      return { tone: "red", label: "closed", strikethrough: true };
+    default:
+      return casesHandled(state);
+  }
+}
+function statusAppearance(status) {
+  if (status.tag === "Unavailable") {
+    return {
+      tone: "gray",
+      label: status.diagnostic === undefined ? "status unavailable" : diagnosticLabels[status.diagnostic],
+      strikethrough: false
+    };
+  }
+  const appearance = stateAppearance(status.state);
+  return status.stale ? { ...appearance, label: `${appearance.label} (stale; ${diagnosticLabels[status.diagnostic]})` } : appearance;
+}
+
+// src/attach.ts
+async function attachPullRequest(dependencies, sessionID, pullRequest, options = {}) {
+  return dependencies.store.attach(sessionID, pullRequest, {
+    async validate() {
+      const batch = await dependencies.github.get([pullRequest], options);
+      if (!batch.ok)
+        return batch;
+      const item = batch.value[0];
+      if (item === undefined)
+        throw new Error("GitHub client omitted the requested pull request");
+      if (!item.ok)
+        return item;
+      return { ok: true, value: undefined };
+    }
+  });
+}
+var invalidPullRequestInput = {
+  ok: false,
+  error: {
+    tag: "InvalidPullRequestInput",
+    message: "Expected https://github.com/<owner>/<repository>/pull/<positive-integer>, github.com/<owner>/<repository>/pull/<positive-integer>, or a positive pull request number"
+  }
+};
+var repositoryResolutionFailed = {
+  tag: "RepositoryResolutionFailed",
+  message: "Unable to resolve the current GitHub repository with gh; attach with a full URL instead"
+};
+var repositoryResolutionCancelled = {
+  ok: false,
+  error: { tag: "RepositoryResolutionCancelled" }
+};
+function isCancellation2(cause, signal) {
+  if (signal?.aborted)
+    return true;
+  return cause instanceof Error && cause.name === "AbortError";
+}
+function parseRepositoryPullRequest(stdout, number) {
+  let decoded;
+  try {
+    decoded = JSON.parse(stdout);
+  } catch {
+    return { ok: false, error: repositoryResolutionFailed };
+  }
+  if (decoded === null || typeof decoded !== "object" || !("url" in decoded) || typeof decoded.url !== "string" || decoded.url === "") {
+    return { ok: false, error: repositoryResolutionFailed };
+  }
+  const repositoryUrl = decoded.url.endsWith("/") ? decoded.url.slice(0, -1) : decoded.url;
+  const pullRequest = parsePullRequestUrl(`${repositoryUrl}/pull/${number}`);
+  return pullRequest.ok ? pullRequest : { ok: false, error: repositoryResolutionFailed };
+}
+async function resolvePullRequestInput(input, options) {
+  const direct = parsePullRequestUrl(input);
+  if (direct.ok)
+    return direct;
+  if (input.trim() !== input || !/^\d+$/.test(input))
+    return invalidPullRequestInput;
+  const number = Number(input);
+  if (!Number.isSafeInteger(number) || number <= 0)
+    return invalidPullRequestInput;
+  let stdout;
+  try {
+    const result = await (options.runner ?? execFileRunner)("gh", ["repo", "view", "--json", "url"], {
+      cwd: options.directory,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    stdout = result.stdout;
+  } catch (cause) {
+    if (isCancellation2(cause, options.signal))
+      return repositoryResolutionCancelled;
+    return { ok: false, error: { ...repositoryResolutionFailed, cause } };
+  }
+  return parseRepositoryPullRequest(stdout, number);
+}
+
 // src/state.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createHash, randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
 var maximumPullRequestsPerSession = 20;
 var invalidStateFile = {
   ok: false,
@@ -1641,7 +2552,7 @@ var lockUpdateMilliseconds = 2000;
 function stateUnavailable(operation, message, cause) {
   return { tag: "StateUnavailable", operation, message, cause };
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function hasExactKeys(value, keys) {
@@ -1649,7 +2560,7 @@ function hasExactKeys(value, keys) {
   return actual.length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 }
 function parseState(input) {
-  if (!isRecord(input) || !hasExactKeys(input, ["version", "pullRequests"]))
+  if (!isRecord2(input) || !hasExactKeys(input, ["version", "pullRequests"]))
     return invalidStateFile;
   if (input.version !== 1 || !Array.isArray(input.pullRequests))
     return invalidStateFile;
@@ -1658,7 +2569,7 @@ function parseState(input) {
   const attachments = [];
   const seen = new Set;
   for (const item of input.pullRequests) {
-    if (!isRecord(item) || !hasExactKeys(item, ["url", "attachedAt"]))
+    if (!isRecord2(item) || !hasExactKeys(item, ["url", "attachedAt"]))
       return invalidStateFile;
     if (typeof item.url !== "string" || typeof item.attachedAt !== "string")
       return invalidStateFile;
@@ -1686,12 +2597,30 @@ function defaultStateDirectory(environment = process.env, home = homedir()) {
 function createStateStore(options = {}) {
   const directory = options.directory ?? defaultStateDirectory();
   const now = options.now ?? (() => new Date);
+  const lockStateFile = options.lock ?? import_proper_lockfile.lock;
+  const attachTails = new Map;
+  async function enqueueAttach(sessionID, operation) {
+    const previous = attachTails.get(sessionID) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    attachTails.set(sessionID, current);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (attachTails.get(sessionID) === current)
+        attachTails.delete(sessionID);
+    }
+  }
   async function acquireLock(sessionID) {
     const stateFile = join(directory, fileName(sessionID));
     let compromised;
     try {
       await mkdir(directory, { recursive: true });
-      const release = await import_proper_lockfile.lock(stateFile, {
+      const release = await lockStateFile(stateFile, {
         realpath: false,
         stale: lockStaleMilliseconds,
         update: lockUpdateMilliseconds,
@@ -1791,9 +2720,29 @@ function createStateStore(options = {}) {
       };
     }
   }
-  return {
-    list: read,
-    async attach(sessionID, pullRequest) {
+  async function attach(sessionID, pullRequest, attachOptions = {}) {
+    return enqueueAttach(sessionID, async () => {
+      if (attachOptions.validate !== undefined) {
+        const current = await read(sessionID);
+        if (!current.ok)
+          return current;
+        if (current.value.some((attachment) => attachment.pullRequest.url === pullRequest.url)) {
+          return { ok: true, value: "already_attached" };
+        }
+        if (current.value.length >= maximumPullRequestsPerSession) {
+          return {
+            ok: false,
+            error: {
+              tag: "AttachmentLimitReached",
+              limit: maximumPullRequestsPerSession,
+              message: "A session can track at most 20 pull requests"
+            }
+          };
+        }
+        const validation = await attachOptions.validate();
+        if (!validation.ok)
+          return validation;
+      }
       return withLock(sessionID, async () => {
         const current = await read(sessionID);
         if (!current.ok)
@@ -1816,7 +2765,11 @@ function createStateStore(options = {}) {
           return written;
         return { ok: true, value: "added" };
       });
-    },
+    });
+  }
+  return {
+    list: read,
+    attach,
     async detach(sessionID, pullRequest) {
       return withLock(sessionID, async () => {
         const current = await read(sessionID);
@@ -1895,7 +2848,7 @@ function formatReferenceList(references) {
     return references.join(" and ");
   return `${references.slice(0, -1).join(", ")}, and ${references.at(-1)}`;
 }
-function createServerHooks(store) {
+function createServerHooks(store, github = createGitHubClient()) {
   return {
     async event({ event }) {
       if (event.type !== "session.deleted")
@@ -1905,16 +2858,32 @@ function createServerHooks(store) {
         throw toToolError(result.error);
     },
     tool: {
+      pr_list: tool({
+        description: "List pull requests attached to the current OpenCode session.",
+        args: {},
+        async execute(_args, context) {
+          const result = await store.list(context.sessionID);
+          if (!result.ok)
+            throw toToolError(result.error);
+          if (result.value.length === 0)
+            return "No pull requests are attached to this session.";
+          return `Attached pull requests:
+${result.value.map((attachment) => `- ${attachment.pullRequest.url}`).join(`
+`)}`;
+        }
+      }),
       pr_attach: tool({
-        description: "Attach a canonical GitHub pull request URL to the current OpenCode session.",
+        description: "Attach a GitHub pull request URL to the current OpenCode session.",
         args: {
-          url: tool.schema.string().describe("A https://github.com/<owner>/<repository>/pull/<number> URL")
+          url: tool.schema.string().describe("A https://github.com/<owner>/<repository>/pull/<number> or github.com/<owner>/<repository>/pull/<number> URL")
         },
         async execute(args, context) {
           const pullRequest = parsePullRequestUrl(args.url);
           if (!pullRequest.ok)
             throw new PrToolError(pullRequest.error.tag, pullRequest.error.message);
-          const result = await store.attach(context.sessionID, pullRequest.value);
+          const result = await attachPullRequest({ store, github }, context.sessionID, pullRequest.value, {
+            signal: context.abort
+          });
           if (!result.ok)
             throw toToolError(result.error);
           const reference = formatPullRequestRef(pullRequest.value);
@@ -1922,14 +2891,14 @@ function createServerHooks(store) {
         }
       }),
       pr_detach: tool({
-        description: "Detach a pull request from the current OpenCode session by positive number or canonical URL.",
+        description: "Detach a pull request from the current OpenCode session by positive number or GitHub URL.",
         args: {
-          pull_request: tool.schema.union([tool.schema.number().int().positive().max(Number.MAX_SAFE_INTEGER), tool.schema.string()]).describe("A positive pull request number or https://github.com/<owner>/<repository>/pull/<number> URL")
+          pull_request: tool.schema.union([tool.schema.number().int().positive().max(Number.MAX_SAFE_INTEGER), tool.schema.string()]).describe("https://github.com/owner/repository/pull/123, github.com/owner/repository/pull/123, or 123")
         },
         async execute(args, context) {
           if (typeof args.pull_request === "number") {
             if (!Number.isSafeInteger(args.pull_request) || args.pull_request <= 0) {
-              throw new PrToolError("InvalidPullRequestNumber", "Expected a positive pull request number or canonical GitHub URL");
+              throw new PrToolError("InvalidPullRequestNumber", "Expected 123, https://github.com/owner/repository/pull/123, or github.com/owner/repository/pull/123");
             }
             const result2 = await store.detachByNumber(context.sessionID, args.pull_request);
             if (!result2.ok)
@@ -1958,7 +2927,7 @@ function createServerHooks(store) {
 }
 var plugin = {
   id: "opencode-pr-tracker",
-  server: async () => createServerHooks(createStateStore())
+  server: async () => createServerHooks(createStateStore(), createGitHubClient())
 };
 var server_default = plugin;
 export {
@@ -1967,4 +2936,4 @@ export {
   PrToolError
 };
 
-//# debugId=8B547DD45DB1BAE364756E2164756E21
+//# debugId=A879251DAA53DE8064756E2164756E21