paperclip-github-plugin 0.6.0 → 0.6.1

package/README.md

@@ -78,6 +78,8 @@ Each mapped project can expose a **Pull Requests** entry in the sidebar that ope
 
 Paperclip issue linkage on the queue prefers the GitHub issue that the pull request closes, so imported GitHub issues and delivery work stay connected in the same project view. If a pull request has no closing-issue-backed link yet, the queue falls back to the Paperclip issue created directly from that pull request and updates the table immediately when that create action returns.
 
+Those pull-request-created Paperclip issues also stay in the scheduled/manual sync loop even when the pull request does not close a GitHub issue. GitHub Sync checks their CI, merge state, and review threads so new failures or unresolved feedback move the Paperclip issue back into active work.
+
 The issue detail panel and sync-created comment annotations also preserve cross-repository linked pull requests, showing those PRs with their real repository path so operators land in the right place on GitHub.
 
 ### Agent workflows built in

package/dist/manifest.js

@@ -516,7 +516,7 @@ var require2 = createRequire(import.meta.url);
 var packageJson = require2("../package.json");
 var DASHBOARD_WIDGET_CAPABILITY = "ui.dashboardWidget.register";
 var SCHEDULE_TICK_CRON = "* * * * *";
-var MANIFEST_VERSION = "0.6.0"?.trim() || typeof packageJson.version === "string" && packageJson.version.trim() || process.env.npm_package_version?.trim() || "0.0.0-dev";
+var MANIFEST_VERSION = "0.6.1"?.trim() || typeof packageJson.version === "string" && packageJson.version.trim() || process.env.npm_package_version?.trim() || "0.0.0-dev";
 var manifest = {
   id: GITHUB_SYNC_PLUGIN_ID,
   apiVersion: 1,

package/dist/worker.js

@@ -4262,6 +4262,12 @@ function countImportedIssuesForMappings(importRegistry, mappings) {
 function buildTrackedIssueProgressKey(mapping, githubIssueId) {
   return `${mapping.id}:${githubIssueId}`;
 }
+function buildTrackedPullRequestIssueProgressKey(mapping, record) {
+  return `${mapping.id}:pull-request:${record.paperclipIssueId}:${buildGitHubPullRequestReferenceKey({
+    number: record.data.githubPullRequestNumber,
+    repositoryUrl: record.data.repositoryUrl
+  })}`;
+}
 function buildImportedIssueRecord(mapping, issue, paperclipIssueId, importedAt) {
   return {
     mappingId: mapping.id,
@@ -5104,6 +5110,27 @@ function buildSyncFallbackExecutionStatePatch(params) {
   }
   return void 0;
 }
+function describeGitHubLinkedPullRequestsStatusReason(linkedPullRequests) {
+  const linkedPullRequestSubject = linkedPullRequests.length === 1 ? "the linked pull request" : "linked pull requests";
+  const linkedPullRequestVerb = linkedPullRequests.length === 1 ? "has" : "have";
+  const blockingConditions = [...new Set(
+    linkedPullRequests.flatMap((pullRequest) => listGitHubPullRequestSyncBlockingConditions(pullRequest))
+  )];
+  const hasUnfinishedCi = linkedPullRequests.some((pullRequest) => pullRequest.ciState === "unfinished");
+  const hasUnknownMergeability = linkedPullRequests.some(
+    (pullRequest) => pullRequest.mergeStateStatus === "unknown"
+  );
+  if (blockingConditions.length > 0) {
+    return `${linkedPullRequestSubject} ${linkedPullRequestVerb} ${formatPlainTextList(blockingConditions)}`;
+  }
+  if (hasUnfinishedCi) {
+    return `${linkedPullRequestSubject} still ${linkedPullRequestVerb} unfinished CI jobs`;
+  }
+  if (hasUnknownMergeability) {
+    return `${linkedPullRequestSubject} ${linkedPullRequestVerb} unknown mergeability`;
+  }
+  return `${linkedPullRequestSubject} ${linkedPullRequestVerb} green CI with all review threads resolved`;
+}
 function describeGitHubStatusTransitionReason(params) {
   const { snapshot, hasTrustedNewComment, maintainerAuthoredImportedIssue } = params;
   if (snapshot.state === "closed") {
@@ -5125,25 +5152,7 @@ function describeGitHubStatusTransitionReason(params) {
     }
     return "the GitHub issue is open with no linked pull requests";
   }
-  const linkedPullRequestSubject = snapshot.linkedPullRequests.length === 1 ? "the linked pull request" : "linked pull requests";
-  const linkedPullRequestVerb = snapshot.linkedPullRequests.length === 1 ? "has" : "have";
-  const blockingConditions = [...new Set(
-    snapshot.linkedPullRequests.flatMap((pullRequest) => listGitHubPullRequestSyncBlockingConditions(pullRequest))
-  )];
-  const hasUnfinishedCi = snapshot.linkedPullRequests.some((pullRequest) => pullRequest.ciState === "unfinished");
-  const hasUnknownMergeability = snapshot.linkedPullRequests.some(
-    (pullRequest) => pullRequest.mergeStateStatus === "unknown"
-  );
-  if (blockingConditions.length > 0) {
-    return `${linkedPullRequestSubject} ${linkedPullRequestVerb} ${formatPlainTextList(blockingConditions)}`;
-  }
-  if (hasUnfinishedCi) {
-    return `${linkedPullRequestSubject} still ${linkedPullRequestVerb} unfinished CI jobs`;
-  }
-  if (hasUnknownMergeability) {
-    return `${linkedPullRequestSubject} ${linkedPullRequestVerb} unknown mergeability`;
-  }
-  return `${linkedPullRequestSubject} ${linkedPullRequestVerb} green CI with all review threads resolved`;
+  return describeGitHubLinkedPullRequestsStatusReason(snapshot.linkedPullRequests);
 }
 function buildStatusTransitionCommentAnnotation(params) {
   const { repository, snapshot, previousStatus, nextStatus, reason } = params;
@@ -5186,6 +5195,10 @@ function buildPaperclipIssueStatusTransitionComment(params) {
     })
   };
 }
+function buildPaperclipPullRequestIssueStatusTransitionComment(params) {
+  const reason = describeGitHubLinkedPullRequestsStatusReason([params.pullRequest]);
+  return `GitHub Sync updated the status from \`${formatPaperclipIssueStatus(params.previousStatus)}\` to \`${formatPaperclipIssueStatus(params.nextStatus)}\` because ${reason}.`;
+}
 function resolvePaperclipIssueStatus(params) {
   const {
     currentStatus,
@@ -5218,6 +5231,15 @@ function resolvePaperclipIssueStatus(params) {
   }
   return currentStatus;
 }
+function resolvePaperclipPullRequestIssueStatus(params) {
+  const { currentStatus, pullRequest, hasExecutorHandoffTarget } = params;
+  if (currentStatus === "done" || currentStatus === "cancelled") {
+    return currentStatus;
+  }
+  return resolvePaperclipStatusFromLinkedPullRequests([pullRequest], {
+    preferInProgress: hasExecutorHandoffTarget
+  });
+}
 async function listLinkedPullRequestsForIssue(octokit, repository, issueNumber) {
   const linkedPullRequests = [];
   const seenPullRequestKeys = /* @__PURE__ */ new Set();
@@ -6531,6 +6553,52 @@ async function listGitHubPullRequestLinkRecords(ctx, query = {}) {
   }
   return records;
 }
+function doesGitHubPullRequestLinkRecordMatchMapping(record, mapping) {
+  if (record.data.repositoryUrl !== getNormalizedMappingRepositoryUrl(mapping)) {
+    return false;
+  }
+  if (record.data.companyId && record.data.companyId !== mapping.companyId) {
+    return false;
+  }
+  if (record.data.paperclipProjectId && record.data.paperclipProjectId !== mapping.paperclipProjectId) {
+    return false;
+  }
+  return Boolean(mapping.companyId && mapping.paperclipProjectId);
+}
+function doesGitHubPullRequestLinkRecordMatchTarget(record, target) {
+  if (!target) {
+    return true;
+  }
+  switch (target.kind) {
+    case "company":
+      return !record.data.companyId || record.data.companyId === target.companyId;
+    case "project":
+      return (!record.data.companyId || record.data.companyId === target.companyId) && (!record.data.paperclipProjectId || record.data.paperclipProjectId === target.projectId);
+    case "issue":
+      return Boolean(target.issueId && record.paperclipIssueId === target.issueId);
+    default:
+      return true;
+  }
+}
+async function listGitHubPullRequestIssueLinksForMapping(ctx, mapping, target) {
+  const records = await listGitHubPullRequestLinkRecords(ctx, {
+    ...target?.kind === "issue" && target.issueId ? { paperclipIssueId: target.issueId } : {}
+  });
+  const recordsByKey = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!doesGitHubPullRequestLinkRecordMatchMapping(record, mapping) || !doesGitHubPullRequestLinkRecordMatchTarget(record, target)) {
+      continue;
+    }
+    recordsByKey.set(
+      `${record.paperclipIssueId}:${buildGitHubPullRequestReferenceKey({
+        number: record.data.githubPullRequestNumber,
+        repositoryUrl: record.data.repositoryUrl
+      })}`,
+      record
+    );
+  }
+  return [...recordsByKey.values()];
+}
 async function findStoredStatusTransitionCommentAnnotation(ctx, params) {
   const issueId = params.issueId.trim();
   const commentId = params.commentId.trim();
@@ -8140,6 +8208,171 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
     updatedDescriptionsCount
   };
 }
+async function synchronizePaperclipPullRequestIssueStatuses(ctx, octokit, mapping, advancedSettings, pullRequestLinks, paperclipApiBaseUrl, pullRequestStatusCache, syncFailureContext, failures, assertNotCancelled, onProgress) {
+  if (!mapping.companyId || !mapping.paperclipProjectId || !ctx.issues || typeof ctx.issues.get !== "function" || typeof ctx.issues.update !== "function") {
+    return {
+      updatedStatusesCount: 0
+    };
+  }
+  let updatedStatusesCount = 0;
+  let completedIssueCount = 0;
+  const mappingCompanyId = mapping.companyId;
+  const mappingProjectId = mapping.paperclipProjectId;
+  const totalIssueCount = pullRequestLinks.length;
+  const queuedIssueWakeups = [];
+  for (const pullRequestLink of pullRequestLinks) {
+    if (assertNotCancelled) {
+      await assertNotCancelled();
+    }
+    try {
+      const pullRequestRepository = requireRepositoryReference(pullRequestLink.data.repositoryUrl);
+      updateSyncFailureContext(syncFailureContext, {
+        phase: "evaluating_github_status",
+        repositoryUrl: pullRequestRepository.url,
+        githubIssueNumber: void 0
+      });
+      const pullRequestResponse = await octokit.rest.pulls.get({
+        owner: pullRequestRepository.owner,
+        repo: pullRequestRepository.repo,
+        pull_number: pullRequestLink.data.githubPullRequestNumber,
+        headers: {
+          "X-GitHub-Api-Version": GITHUB_API_VERSION
+        }
+      });
+      const livePullRequestState = getPullRequestApiState({
+        state: pullRequestResponse.data.state,
+        merged: pullRequestResponse.data.merged
+      }) === "open" ? "open" : "closed";
+      if (livePullRequestState !== pullRequestLink.data.githubPullRequestState || pullRequestResponse.data.html_url !== pullRequestLink.data.githubPullRequestUrl || pullRequestResponse.data.title !== pullRequestLink.data.title) {
+        await upsertGitHubPullRequestLinkRecord(ctx, {
+          companyId: pullRequestLink.data.companyId ?? mappingCompanyId,
+          projectId: pullRequestLink.data.paperclipProjectId ?? mappingProjectId,
+          issueId: pullRequestLink.paperclipIssueId,
+          repositoryUrl: pullRequestRepository.url,
+          pullRequestNumber: pullRequestLink.data.githubPullRequestNumber,
+          pullRequestUrl: pullRequestResponse.data.html_url ?? pullRequestLink.data.githubPullRequestUrl,
+          pullRequestTitle: pullRequestResponse.data.title || pullRequestLink.data.title || `Pull request #${pullRequestLink.data.githubPullRequestNumber}`,
+          pullRequestState: livePullRequestState
+        });
+      }
+      if (livePullRequestState !== "open") {
+        continue;
+      }
+      const pullRequest = await getGitHubPullRequestStatusSnapshot(
+        octokit,
+        pullRequestRepository,
+        pullRequestLink.data.githubPullRequestNumber,
+        pullRequestStatusCache
+      );
+      const paperclipIssue = await ctx.issues.get(pullRequestLink.paperclipIssueId, mapping.companyId);
+      if (!paperclipIssue) {
+        continue;
+      }
+      const paperclipIssueSyncContext = getPaperclipIssueSyncContext(paperclipIssue);
+      const executorTransitionAssignee = resolvePaperclipIssueExecutorAssignee(
+        paperclipIssueSyncContext,
+        advancedSettings
+      );
+      const nextStatus = resolvePaperclipPullRequestIssueStatus({
+        currentStatus: paperclipIssue.status,
+        pullRequest,
+        hasExecutorHandoffTarget: Boolean(executorTransitionAssignee)
+      });
+      const nextTransitionAssignee = resolveSyncTransitionAssignee({
+        nextStatus,
+        syncContext: paperclipIssueSyncContext,
+        advancedSettings
+      });
+      const shouldClearTransitionAssignee = nextStatus === "in_review" && nextTransitionAssignee === null && paperclipIssueSyncContext.assignee !== null;
+      const nextAssigneeChanged = nextTransitionAssignee ? !doesPaperclipIssueAssigneeMatch(paperclipIssueSyncContext.assignee, nextTransitionAssignee.principal) : false;
+      const shouldWakeTransitionAssignee = paperclipIssue.status !== nextStatus && nextTransitionAssignee?.principal.kind === "agent" && isActionablePaperclipIssueStatus(nextStatus) && (nextAssigneeChanged || paperclipIssue.status !== nextStatus);
+      if (paperclipIssue.status === nextStatus) {
+        if (shouldClearTransitionAssignee) {
+          updateSyncFailureContext(syncFailureContext, {
+            phase: "updating_paperclip_status",
+            repositoryUrl: pullRequestRepository.url,
+            githubIssueNumber: void 0
+          });
+          await updatePaperclipIssueState(ctx, {
+            companyId: mapping.companyId,
+            issueId: pullRequestLink.paperclipIssueId,
+            currentStatus: paperclipIssue.status,
+            syncContext: paperclipIssueSyncContext,
+            nextStatus,
+            clearAssignee: true,
+            transitionComment: "",
+            paperclipApiBaseUrl
+          });
+        }
+        continue;
+      }
+      const transitionComment = buildPaperclipPullRequestIssueStatusTransitionComment({
+        previousStatus: paperclipIssue.status,
+        nextStatus,
+        pullRequest
+      });
+      updateSyncFailureContext(syncFailureContext, {
+        phase: "updating_paperclip_status",
+        repositoryUrl: pullRequestRepository.url,
+        githubIssueNumber: void 0
+      });
+      await updatePaperclipIssueState(ctx, {
+        companyId: mapping.companyId,
+        issueId: pullRequestLink.paperclipIssueId,
+        currentStatus: paperclipIssue.status,
+        syncContext: paperclipIssueSyncContext,
+        nextStatus,
+        ...nextTransitionAssignee ? { nextAssignee: nextTransitionAssignee.principal } : {},
+        ...shouldClearTransitionAssignee ? { clearAssignee: true } : {},
+        transitionComment,
+        paperclipApiBaseUrl
+      });
+      updatedStatusesCount += 1;
+      if (shouldWakeTransitionAssignee && nextTransitionAssignee?.principal.kind === "agent") {
+        queuedIssueWakeups.push({
+          assigneeAgentId: nextTransitionAssignee.principal.id,
+          paperclipIssueId: pullRequestLink.paperclipIssueId,
+          reason: STATUS_TRANSITION_WAKE_REASON,
+          mutation: "status_transition",
+          previousStatus: paperclipIssue.status,
+          nextStatus
+        });
+      }
+    } catch (error) {
+      if (isGitHubRateLimitError(error)) {
+        throw error;
+      }
+      recordRecoverableSyncFailure(ctx, failures, error, syncFailureContext);
+      continue;
+    } finally {
+      completedIssueCount += 1;
+      if (onProgress) {
+        await onProgress({
+          pullRequestLink,
+          completedIssueCount,
+          totalIssueCount
+        });
+      }
+    }
+  }
+  await mapWithConcurrency(
+    queuedIssueWakeups,
+    IMPORTED_ISSUE_WAKEUP_CONCURRENCY,
+    async (queuedWakeup) => wakePaperclipIssueAssignee(ctx, {
+      assigneeAgentId: queuedWakeup.assigneeAgentId,
+      paperclipIssueId: queuedWakeup.paperclipIssueId,
+      companyId: mapping.companyId,
+      paperclipApiBaseUrl,
+      reason: queuedWakeup.reason,
+      mutation: queuedWakeup.mutation,
+      previousStatus: queuedWakeup.previousStatus,
+      nextStatus: queuedWakeup.nextStatus
+    })
+  );
+  return {
+    updatedStatusesCount
+  };
+}
 async function getResolvedConfig(ctx) {
   const [savedConfig, externalConfig] = await Promise.all([
     ctx.config.get(),
@@ -11697,6 +11930,14 @@ async function performSync(ctx, trigger, options = {}) {
     completedTrackedIssueKeys.add(key);
     completedTrackedIssueCount += 1;
   }
+  function markTrackedPullRequestIssueProcessed(mapping, record) {
+    const key = buildTrackedPullRequestIssueProgressKey(mapping, record);
+    if (completedTrackedIssueKeys.has(key)) {
+      return;
+    }
+    completedTrackedIssueKeys.add(key);
+    completedTrackedIssueCount += 1;
+  }
   function recordCompanyBacklogSnapshotsFromPlans(repositoryPlans2) {
     if (options.target?.kind === "project" || options.target?.kind === "issue") {
       return;
@@ -11804,12 +12045,13 @@ async function performSync(ctx, trigger, options = {}) {
         const importRegistryByIssueId = new Map(
           importedIssueRecords.map((entry) => [entry.githubIssueId, entry])
         );
+        const pullRequestLinks = await listGitHubPullRequestIssueLinksForMapping(ctx, mapping, options.target);
         const ensuredPaperclipIssueIds = /* @__PURE__ */ new Map();
         const trackedIssueIds = /* @__PURE__ */ new Set([
           ...issues.map((issue) => issue.id),
           ...importRegistryByIssueId.keys()
         ]);
-        const trackedIssueCount = [...trackedIssueIds].filter((issueId) => allIssuesById.has(issueId)).length;
+        const trackedIssueCount = [...trackedIssueIds].filter((issueId) => allIssuesById.has(issueId)).length + pullRequestLinks.length;
         totalTrackedIssueCount += trackedIssueCount;
         syncedIssuesCount = totalTrackedIssueCount;
         currentProgress = {
@@ -11828,6 +12070,7 @@ async function performSync(ctx, trigger, options = {}) {
           allIssues: eligibleIssues,
           issues,
           allIssuesById,
+          pullRequestLinks,
           trackedIssueCount
         });
       } catch (error) {
@@ -11863,7 +12106,7 @@ async function performSync(ctx, trigger, options = {}) {
     for (const plan of repositoryPlans) {
       await throwIfSyncCancelled();
       try {
-        const { mapping, advancedSettings, repository, repositoryIndex, allIssuesById, issues } = plan;
+        const { mapping, advancedSettings, repository, repositoryIndex, allIssuesById, issues, pullRequestLinks } = plan;
         const companyId = mapping.companyId;
         let availableLabels = companyId ? companyLabelDirectoryCache.get(companyId) : void 0;
         if (!availableLabels) {
@@ -11916,6 +12159,15 @@ async function performSync(ctx, trigger, options = {}) {
               }
             }
           }
+          for (const pullRequestLink of pullRequestLinks) {
+            const pullRequestRepository = requireRepositoryReference(pullRequestLink.data.repositoryUrl);
+            const entry = openLinkedPullRequestNumbersByRepository.get(pullRequestRepository.url) ?? {
+              repository: pullRequestRepository,
+              numbers: /* @__PURE__ */ new Set()
+            };
+            entry.numbers.add(pullRequestLink.data.githubPullRequestNumber);
+            openLinkedPullRequestNumbersByRepository.set(pullRequestRepository.url, entry);
+          }
           for (const entry of openLinkedPullRequestNumbersByRepository.values()) {
             await warmGitHubPullRequestStatusCache(
               octokit,
@@ -12053,6 +12305,33 @@ async function performSync(ctx, trigger, options = {}) {
         updatedStatusesCount += synchronizationResult.updatedStatusesCount;
         updatedLabelsCount += synchronizationResult.updatedLabelsCount;
         updatedDescriptionsCount += synchronizationResult.updatedDescriptionsCount;
+        const pullRequestSynchronizationResult = await synchronizePaperclipPullRequestIssueStatuses(
+          ctx,
+          octokit,
+          mapping,
+          advancedSettings,
+          pullRequestLinks,
+          paperclipApiBaseUrl,
+          pullRequestStatusCache,
+          failureContext,
+          recoverableFailures,
+          throwIfSyncCancelled,
+          async (progress) => {
+            markTrackedPullRequestIssueProcessed(mapping, progress.pullRequestLink);
+            const pullRequestRepository = requireRepositoryReference(progress.pullRequestLink.data.repositoryUrl);
+            currentProgress = {
+              phase: "syncing",
+              totalRepositoryCount: mappings.length,
+              currentRepositoryIndex: repositoryIndex,
+              currentRepositoryUrl: repository.url,
+              completedIssueCount: completedTrackedIssueCount,
+              totalIssueCount: totalTrackedIssueCount,
+              detailLabel: `Synced pull request #${progress.pullRequestLink.data.githubPullRequestNumber} in ${pullRequestRepository.owner}/${pullRequestRepository.repo}.`
+            };
+            await persistRunningProgress(progress.completedIssueCount === progress.totalIssueCount);
+          }
+        );
+        updatedStatusesCount += pullRequestSynchronizationResult.updatedStatusesCount;
       } catch (error) {
         if (error instanceof SyncCancellationError || isGitHubRateLimitError(error)) {
           throw error;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "paperclip-github-plugin",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Paperclip plugin for synchronizing GitHub issues into Paperclip projects.",
   "license": "Apache-2.0",
   "type": "module",
-  "packageManager": "pnpm@10.33.0",
+  "packageManager": "pnpm@10.33.2",
   "engines": {
     "node": ">=20"
   },