opencode-forgekeeper 2.1.0 → 2.2.0

package/dist/tui.js

@@ -73,14 +73,182 @@ class ForgeError extends Error {
 var query = (text) => text;
 var typed = (transport) => async (host, query2, variables) => await transport(host, query2, variables);
 
-// packages/forgekeeper/src/gitlab-feedback.ts
+// packages/forgekeeper/src/github-feedback.ts
 var PAGE_SIZE = 100;
 var MAX_COMMENT_PAGES = 20;
+var MAX_FETCH_REQUESTS = 200;
+var author = "author { __typename login ... on User { id } ... on Bot { id } ... on Mannequin { id } }";
+var page = "pageInfo { hasPreviousPage startCursor }";
+var INLINE_FIELDS = `id url state createdAt publishedAt lastEditedAt isMinimized ${author}`;
+var listQuery = (field, connection) => query(`query($owner: String!, $repo: String!, $number: Int!, $before: String) {
+  viewer { id }
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      ${field}(last: ${PAGE_SIZE}, before: $before) { ${page} nodes { ${connection} } }
+    }
+  }
+}`);
+var ISSUE_COMMENTS_QUERY = listQuery("comments", `id url createdAt publishedAt lastEditedAt isMinimized ${author}`);
+var REVIEWS_QUERY = listQuery("reviews", `id url state body submittedAt lastEditedAt isMinimized ${author}`);
+var THREADS_QUERY = listQuery("reviewThreads", `id isResolved comments(last: ${PAGE_SIZE}) { ${page} nodes { ${INLINE_FIELDS} } }`);
+var THREAD_COMMENTS_QUERY = query(`query($id: ID!, $before: String) {
+  node(id: $id) {
+    ... on PullRequestReviewThread {
+      comments(last: ${PAGE_SIZE}, before: $before) { ${page} nodes { ${INLINE_FIELDS} } }
+    }
+  }
+}`);
+var REVIEW_STATES = new Set(["COMMENTED", "CHANGES_REQUESTED", "APPROVED"]);
+var time = (...values) => {
+  const value = values.find((candidate) => candidate);
+  return value ? Date.parse(value) : NaN;
+};
+var activity = (lastEditedAt, postedAt) => {
+  const edited = lastEditedAt ? Date.parse(lastEditedAt) : NaN;
+  return Number.isFinite(edited) ? Math.max(edited, postedAt) : postedAt;
+};
+function build({ node, postedAt, editedAt, resolved }) {
+  if (node.isMinimized || !node.author?.id || !Number.isFinite(postedAt) || !Number.isFinite(editedAt))
+    return;
+  const { __typename, login } = node.author;
+  return {
+    id: node.id,
+    order: postedAt,
+    url: node.url ?? "",
+    editedAt,
+    resolved,
+    bot: __typename === "Bot" || login.endsWith("[bot]"),
+    authorID: node.author.id,
+    username: login
+  };
+}
+function toIssueComment(node) {
+  const postedAt = time(node.publishedAt, node.createdAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved: false
+  });
+}
+function toReview(node) {
+  if (!REVIEW_STATES.has(node.state) || !node.body.trim())
+    return;
+  const postedAt = time(node.submittedAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved: false
+  });
+}
+function toInlineComment(node, resolved) {
+  if (node.state === "PENDING")
+    return;
+  const postedAt = time(node.publishedAt, node.createdAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved
+  });
+}
+var commentWindow = { pages: MAX_COMMENT_PAGES, completeAtLimit: true };
+var allThreads = { pages: MAX_FETCH_REQUESTS, completeAtLimit: false };
+async function readList(graphql, host, base, text, field, limit = commentWindow) {
+  const pages = [];
+  let viewer;
+  let before;
+  const result = (complete) => ({
+    items: pages.toReversed().flat(),
+    viewer,
+    complete
+  });
+  for (let count = 0;count < limit.pages; count++) {
+    const variables = before ? { ...base, before } : base;
+    const data = await graphql(host, text, variables);
+    viewer ??= data.viewer?.id ?? undefined;
+    const connection = data.repository?.pullRequest?.[field];
+    if (!connection)
+      return count === 0 ? { viewer, complete: false } : result(false);
+    pages.push(connection.nodes);
+    if (!connection.pageInfo.hasPreviousPage)
+      return result(true);
+    before = connection.pageInfo.startCursor ?? undefined;
+    if (!before)
+      return result(false);
+  }
+  return result(limit.completeAtLimit);
+}
+async function readOlderComments(graphql, host, thread) {
+  if (!thread.comments)
+    return { comments: [], complete: false };
+  const pages = [];
+  let before = thread.comments?.pageInfo.hasPreviousPage ? thread.comments.pageInfo.startCursor ?? undefined : undefined;
+  if (thread.comments?.pageInfo.hasPreviousPage && !before)
+    return { comments: [], complete: false };
+  for (let count = 1;before && count < MAX_COMMENT_PAGES; count++) {
+    const data = await graphql(host, THREAD_COMMENTS_QUERY, { id: thread.id, before });
+    const connection = data.node?.comments;
+    if (!connection)
+      return { comments: pages.toReversed().flat(), complete: false };
+    pages.push(connection.nodes);
+    before = connection.pageInfo.hasPreviousPage ? connection.pageInfo.startCursor ?? undefined : undefined;
+    if (connection.pageInfo.hasPreviousPage && !before)
+      return { comments: pages.toReversed().flat(), complete: false };
+  }
+  return { comments: pages.toReversed().flat(), complete: true };
+}
+async function fetchComments(transport, host, project, number) {
+  let requests = 0;
+  const graphql = typed(async (...args) => {
+    if (requests++ >= MAX_FETCH_REQUESTS)
+      return {};
+    return transport(...args);
+  });
+  const [owner, repo] = project.split("/");
+  const base = { owner, repo, number: Number(number) };
+  const [conversation, reviews, threads] = await Promise.all([
+    readList(graphql, host, base, ISSUE_COMMENTS_QUERY, "comments"),
+    readList(graphql, host, base, REVIEWS_QUERY, "reviews"),
+    readList(graphql, host, base, THREADS_QUERY, "reviewThreads", allThreads)
+  ]);
+  if (!conversation.items || !reviews.items || !threads.items)
+    return;
+  const viewerID = conversation.viewer ?? reviews.viewer ?? threads.viewer;
+  let threadsComplete = threads.complete;
+  const inline = [];
+  for (const thread of threads.items) {
+    const older = await readOlderComments(graphql, host, thread);
+    threadsComplete &&= older.complete;
+    for (const node of [...older.comments, ...thread.comments?.nodes ?? []]) {
+      const comment = toInlineComment(node, thread.isResolved);
+      if (comment)
+        inline.push(comment);
+    }
+    inline.sort((a, b) => b.order - a.order);
+    inline.splice(PAGE_SIZE * MAX_COMMENT_PAGES);
+  }
+  const comments = [
+    ...conversation.items.map(toIssueComment),
+    ...reviews.items.map(toReview),
+    ...inline.sort((a, b) => a.order - b.order).slice(-PAGE_SIZE * MAX_COMMENT_PAGES)
+  ].flatMap((comment) => comment ?? []);
+  return {
+    complete: conversation.complete && reviews.complete && threadsComplete && viewerID !== undefined,
+    viewerID,
+    comments: comments.sort((a, b) => a.order - b.order)
+  };
+}
+
+// packages/forgekeeper/src/gitlab-feedback.ts
+var PAGE_SIZE2 = 100;
+var MAX_COMMENT_PAGES2 = 20;
 var COMMENTS_QUERY = query(`query($project: ID!, $iid: String!, $before: String) {
   currentUser { id }
   project(fullPath: $project) {
     mergeRequest(iid: $iid) {
-      notes(last: ${PAGE_SIZE}, before: $before, filter: ONLY_COMMENTS) {
+      notes(last: ${PAGE_SIZE2}, before: $before, filter: ONLY_COMMENTS) {
         pageInfo { hasPreviousPage startCursor }
         nodes {
           id url createdAt updatedAt lastEditedAt system
@@ -109,7 +277,7 @@ function toComment(node) {
     username: node.author.username
   };
 }
-async function fetchComments(transport, host, project, iid) {
+async function fetchComments2(transport, host, project, iid) {
   const graphql = typed(transport);
   const pages = [];
   let viewerID;
@@ -119,7 +287,7 @@ async function fetchComments(transport, host, project, iid) {
     viewerID,
     comments: pages.toReversed().flat()
   });
-  for (let page = 0;page < MAX_COMMENT_PAGES; page++) {
+  for (let page2 = 0;page2 < MAX_COMMENT_PAGES2; page2++) {
     const variables = { project, iid };
     if (before)
       variables.before = before;
@@ -127,7 +295,7 @@ async function fetchComments(transport, host, project, iid) {
     viewerID ??= data.currentUser?.id ?? undefined;
     const connection = data.project?.mergeRequest?.notes;
     if (!connection)
-      return page === 0 ? undefined : snapshot(false);
+      return page2 === 0 ? undefined : snapshot(false);
     pages.push(connection.nodes.flatMap((node) => toComment(node) ?? []));
     if (!connection.pageInfo.hasPreviousPage)
       return snapshot(true);
@@ -140,7 +308,7 @@ async function fetchComments(transport, host, project, iid) {
 
 // packages/forgekeeper/src/gitlab.ts
 var DISCUSSIONS = "pageInfo { hasNextPage endCursor } nodes { resolvable resolved }";
-var PAGE_SIZE2 = 100;
+var PAGE_SIZE3 = 100;
 var MAX_DISCUSSION_PAGES = 50;
 var MERGE_REQUEST_FIELDS = `
   iid title webUrl state draft conflicts approved detailedMergeStatus diffHeadSha updatedAt targetBranch
@@ -149,7 +317,7 @@ var MERGE_REQUEST_FIELDS = `
   targetProject { fullPath }
   headPipeline { status path detailedStatus { label } }
   reviewers(first: 100) { nodes { type username bot mergeRequestInteraction { reviewState approved } } }
-  discussions(first: ${PAGE_SIZE2}) { ${DISCUSSIONS} }
+  discussions(first: ${PAGE_SIZE3}) { ${DISCUSSIONS} }
 `;
 function mergeRequestsQuery(projectCount) {
   const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
@@ -184,7 +352,7 @@ var SOURCE_BRANCH_QUERY = query(`query($project: ID!, $iid: String!) {
 }`);
 var DISCUSSIONS_QUERY = query(`query($project: ID!, $iid: String!, $after: String) {
   project(fullPath: $project) {
-    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE2}, after: $after) { ${DISCUSSIONS} } }
+    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE3}, after: $after) { ${DISCUSSIONS} } }
   }
 }`);
 function classifyError(message, code) {
@@ -223,7 +391,7 @@ function glabGraphQL(run, cwd) {
     return body.data;
   };
 }
-var countUnresolved = (page) => page.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
+var countUnresolved = (page2) => page2.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
 var gitlabTraits = {
   kind: "gitlab",
   noun: "MR",
@@ -258,7 +426,7 @@ var gitlabTraits = {
   feedback: {
     async fetch(run, directory, request) {
       const ref = gitlabTraits.parseUrl(request.url);
-      return ref ? fetchComments(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+      return ref ? fetchComments2(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
     }
   }
 };
@@ -330,22 +498,22 @@ class GitLabForge {
   }
   async unresolvedThreads(host, node) {
     let count = countUnresolved(node.discussions);
-    let page = node.discussions.pageInfo;
+    let page2 = node.discussions.pageInfo;
     let pages = 1;
-    while (page.hasNextPage && page.endCursor && pages < MAX_DISCUSSION_PAGES) {
+    while (page2.hasNextPage && page2.endCursor && pages < MAX_DISCUSSION_PAGES) {
       const data = await this.graphql(host, DISCUSSIONS_QUERY, {
         project: node.targetProject.fullPath,
         iid: node.iid,
-        after: page.endCursor
+        after: page2.endCursor
       });
       const next = data.project?.mergeRequest?.discussions;
       if (!next)
         break;
       count += countUnresolved(next);
-      page = next.pageInfo;
+      page2 = next.pageInfo;
       pages++;
     }
-    return { count, complete: !page.hasNextPage };
+    return { count, complete: !page2.hasNextPage };
   }
   async normalize(host, node) {
     const threads = await this.unresolvedThreads(host, node);
@@ -384,10 +552,12 @@ class GitLabForge {
 }
 
 // packages/forgekeeper/src/github.ts
+var COPILOT_AUTHOR = "copilot-pull-request-reviewer[bot]";
 var fields = `number title url state isDraft mergeable reviewDecision headRefOid headRefName
   headRepository { nameWithOwner } baseRepository { nameWithOwner } baseRefName updatedAt
   reviewThreads(first:100) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
-  reviewRequests(first:100) { nodes { requestedReviewer { ... on User { login } ... on Team { name } } } pageInfo { hasNextPage } }
+  reviewRequests(first:100) { nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { name } } } pageInfo { hasNextPage endCursor } }
+  copilotReviews: reviews(last:1, author:"${COPILOT_AUTHOR}", states:[COMMENTED,CHANGES_REQUESTED,APPROVED,DISMISSED]) { nodes { id state comments { totalCount } } }
   commits(last:1) { nodes { commit { statusCheckRollup { contexts(first:100) {
     nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } }
     pageInfo { hasNextPage endCursor }
@@ -481,8 +651,43 @@ var githubTraits = {
   indicators: (request) => request.reviewDecision === "CHANGES_REQUESTED" ? [{ text: "changes requested", tone: "warning", essential: true }] : [],
   details: (request) => [
     `Review decision: ${request.reviewDecision ? humanize(request.reviewDecision) : "not reported"}`
-  ]
+  ],
+  automatedReview: {
+    name: "GitHub Copilot",
+    status: (request) => copilotStatus(request.copilotReview)
+  },
+  feedback: {
+    async fetch(run, directory, request) {
+      const ref = githubTraits.parseUrl(request.url);
+      return ref ? fetchComments(ghGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+    }
+  }
 };
+function copilotStatus(review) {
+  if (!review)
+    return;
+  const feedback = review.comments > 0 && !review.dismissed;
+  const label = review.dismissed ? "dismissed" : feedback ? "commented" : "no comments";
+  const completed = review.reviewID ? { id: review.reviewID, feedback, label } : undefined;
+  if (review.requested)
+    return { state: "running", label: "reviewing", completed };
+  if (!completed)
+    return;
+  return { state: feedback ? "feedback" : "settled", label, completed };
+}
+var isCopilotReviewer = (login) => /^copilot-pull-request-reviewer(\[bot\])?$/i.test(login ?? "");
+function copilotReview(node) {
+  const requested = node.reviewRequests.nodes.some((request) => isCopilotReviewer(request.requestedReviewer?.login));
+  const latest = node.copilotReviews?.nodes?.find((review) => review);
+  if (!requested && !latest)
+    return;
+  return {
+    requested,
+    reviewID: latest?.id,
+    comments: latest?.comments.totalCount ?? 0,
+    ...latest?.state === "DISMISSED" ? { dismissed: true } : {}
+  };
+}
 
 class GitHubForge {
   traits = githubTraits;
@@ -533,7 +738,7 @@ class GitHubForge {
       const [owner, repo] = target.path.split("/");
       let after;
       let complete = false;
-      for (let page = 0;page < MAX_PAGES; page++) {
+      for (let page2 = 0;page2 < MAX_PAGES; page2++) {
         const data = await this.graphql(target.host, query(`query($owner:String!,$repo:String!,$branch:String!${after ? ",$after:String!" : ""}) {
           repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch${after ? ",after:$after" : ""}) {
             nodes { ${fields} } pageInfo { hasNextPage endCursor }
@@ -563,21 +768,21 @@ class GitHubForge {
   async threads(host, node) {
     const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
     const threads = [...node.reviewThreads.nodes];
-    let page = node.reviewThreads.pageInfo;
-    for (let count = 1;page?.hasNextPage && page.endCursor && count < MAX_PAGES; count++) {
+    let page2 = node.reviewThreads.pageInfo;
+    for (let count = 1;page2?.hasNextPage && page2.endCursor && count < MAX_PAGES; count++) {
       const data = await this.graphql(host, query(`query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
         repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
           reviewThreads(first:100,after:$after) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
-        } } }`), { owner, repo, number: node.number, after: page.endCursor });
+        } } }`), { owner, repo, number: node.number, after: page2.endCursor });
       const next = data.repository?.pullRequest?.reviewThreads;
       if (!next)
         break;
       threads.push(...next.nodes);
-      page = next.pageInfo;
+      page2 = next.pageInfo;
     }
     return {
       unresolved: threads.filter((thread) => !thread.isResolved).length,
-      complete: !page?.hasNextPage
+      complete: !page2?.hasNextPage
     };
   }
   async contexts(host, node) {
@@ -598,7 +803,33 @@ class GitHubForge {
     }
     return { nodes: contexts, complete: !cursor?.hasNextPage };
   }
+  async reviewers(host, node) {
+    const nodes = [...node.reviewRequests.nodes];
+    let reviewerPage = node.reviewRequests.pageInfo;
+    for (let count = 1;reviewerPage?.hasNextPage && count < MAX_PAGES; count++) {
+      if (!reviewerPage.endCursor)
+        throw new ForgeError("request", "GitHub reviewer pagination cursor missing");
+      const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+      const data = await this.graphql(host, query(`query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
+            repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
+              reviewRequests(first:100,after:$after) {
+                nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { name } } }
+                pageInfo { hasNextPage endCursor }
+              }
+            } }
+          }`), { owner, repo, number: node.number, after: reviewerPage.endCursor });
+      const next = data.repository?.pullRequest?.reviewRequests;
+      if (!next)
+        throw new ForgeError("request", "GitHub reviewers unavailable");
+      nodes.push(...next.nodes);
+      reviewerPage = next.pageInfo;
+    }
+    if (reviewerPage?.hasNextPage)
+      throw new ForgeError("request", "GitHub reviewers exceeded the pagination limit");
+    return { nodes, pageInfo: reviewerPage };
+  }
   async normalize(host, node) {
+    const reviewers = await this.reviewers(host, node);
     const [threads, contexts] = [await this.threads(host, node), await this.contexts(host, node)];
     return {
       forge: "github",
@@ -611,11 +842,14 @@ class GitHubForge {
       conflictsKnown: node.mergeable !== "UNKNOWN",
       approved: node.reviewDecision === "APPROVED",
       reviewDecision: node.reviewDecision ?? undefined,
-      awaitingReviewers: node.reviewRequests.nodes.flatMap((request) => {
+      copilotReview: copilotReview({ ...node, reviewRequests: reviewers }),
+      awaitingReviewers: reviewers.nodes.flatMap((request) => {
         const reviewer = request.requestedReviewer;
+        if (reviewer?.__typename === "Bot")
+          return [];
         return reviewer?.login ? [reviewer.login] : reviewer?.name ? [reviewer.name] : [];
       }),
-      reviewersComplete: !node.reviewRequests.pageInfo?.hasNextPage,
+      reviewersComplete: !reviewers.pageInfo?.hasNextPage,
       targetProject: node.baseRepository.nameWithOwner,
       targetBranch: node.baseRefName,
       headSha: node.headRefOid,
@@ -731,7 +965,7 @@ function footerSegments(snapshot) {
   const { lookup, error } = snapshot;
   const stale = error ? [{ text: "stale", tone: "warning", essential: true }] : [];
   if (!lookup || lookup.kind === "none" || lookup.requests.length === 0) {
-    return error ? [{ text: "PR/MR status unavailable", tone: "warning" }] : [];
+    return snapshot.targeted && (error || lookup?.explicitTarget) ? [{ text: "PR/MR status unavailable", tone: "warning" }] : [];
   }
   if (lookup.failed?.length) {
     stale.unshift({
@@ -808,7 +1042,7 @@ function responsiveFooterSegments(snapshot, width) {
   }
   return fitted;
 }
-var time = (value) => new Date(value).toLocaleTimeString();
+var time2 = (value) => new Date(value).toLocaleTimeString();
 function describe(request, head) {
   const traits = traitsOf(request);
   const lines = [
@@ -856,9 +1090,9 @@ function detailsMessage(snapshot) {
       lines.push("", ...describe(request, repository?.head ?? ""));
   }
   if (error)
-    lines.push("", `Last refresh failed at ${time(error.at)}: ${error.message}`);
+    lines.push("", `Last refresh failed at ${time2(error.at)}: ${error.message}`);
   if (fetchedAt !== undefined)
-    lines.push("", `Last fetched: ${time(fetchedAt)}`);
+    lines.push("", `Last fetched: ${time2(fetchedAt)}`);
   return lines.join(`
 `);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-forgekeeper",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "OpenCode plugin that tracks each session's GitHub and GitLab issues and PRs/MRs: title prefixes, a PR/MR status footer, and review notifications",
   "author": {
     "name": "Pedro Pombeiro",