agent-relay-server 0.62.1 → 0.62.3

package/src/services/issue-lifecycle.ts

@@ -22,6 +22,13 @@ export interface LandedIssueLifecycleInput {
   mergedSha?: string;
   subject?: string;
   source?: string;
+  /**
+   * The land happened via a pull request (the squash/merge subject carries a
+   * trailing `(#PR)` that GitHub appends — the PR number, NOT an issue). Bare-backlink
+   * parsing is suppressed in this mode so relay never mistakes the PR number for an
+   * issue to close; GitHub-native keywords + durable association still apply (#482).
+   */
+  prLand?: boolean;
 }
 
 export interface ReopenIssueLifecycleInput {
@@ -44,8 +51,10 @@ export interface IssueLifecycleOptions {
   log?: LogFn;
 }
 
+export type LandIssueRefSource = "association" | "commit" | "backlink";
+
 export type CloseIssueLifecycleResult =
-  | { issueRef: IssueRef; action: "closed"; source: "association" | "commit"; landKey: string }
+  | { issueRef: IssueRef; action: "closed"; source: LandIssueRefSource; landKey: string }
   | { issueRef: IssueRef; action: "skipped"; reason: "already-closed" | "already-processed"; landKey: string }
   | { issueRef: IssueRef; action: "failed"; error: string; landKey: string };
 
@@ -73,6 +82,51 @@ function defaultIssueRepo(): string | undefined {
   return process.env.AGENT_RELAY_DEFAULT_ISSUE_REPO || process.env.GITHUB_REPOSITORY || undefined;
 }
 
+/**
+ * `owner/repo` out of any git remote URL form: `git@github.com:owner/repo.git`,
+ * `https://github.com/owner/repo.git`, `ssh://git@host/owner/repo`, trailing slash/`.git`
+ * optional. Pure — exported for tests.
+ */
+export function parseOwnerRepoFromRemote(url: string | undefined): string | undefined {
+  if (!url) return undefined;
+  const match = url.trim().match(/[:/]([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/);
+  return match?.[1];
+}
+
+let remoteRepoCache: Map<string, string | undefined> | undefined;
+
+function repoFromGitRemote(repoRoot: string | undefined): string | undefined {
+  if (!repoRoot) return undefined;
+  if (!remoteRepoCache) remoteRepoCache = new Map();
+  if (remoteRepoCache.has(repoRoot)) return remoteRepoCache.get(repoRoot);
+  let repo: string | undefined;
+  try {
+    const proc = Bun.spawnSync(["git", "-C", repoRoot, "remote", "get-url", "origin"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    if (proc.exitCode === 0) repo = parseOwnerRepoFromRemote(Buffer.from(proc.stdout).toString("utf8"));
+  } catch {
+    repo = undefined;
+  }
+  remoteRepoCache.set(repoRoot, repo);
+  return repo;
+}
+
+export function __resetRemoteRepoCacheForTests(): void {
+  remoteRepoCache = undefined;
+}
+
+/**
+ * The repo a bare `#NNN` in a land's commit subject resolves against. Derived per-workspace
+ * from its own git remote so a single relay serving many repos closes the RIGHT repo's issue;
+ * env (`AGENT_RELAY_DEFAULT_ISSUE_REPO`/`GITHUB_REPOSITORY`) is an override/fallback.
+ */
+function landDefaultRepo(workspace: LifecycleWorkspace): string | undefined {
+  return repoFromGitRemote(workspace.repoRoot) ?? defaultIssueRepo();
+}
+
 function cleanText(value: string | undefined): string | undefined {
   const cleaned = value?.trim();
   return cleaned || undefined;
@@ -116,33 +170,57 @@ const CLOSING_KEYWORD_RE = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+([^\n\
 const ISSUE_REF_AT_START_RE = /^(https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/issues\/[0-9]+(?:[/?#][^\s,)]*)?|[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+#[0-9]+|#[0-9]+)/;
 const REF_SEPARATOR_RE = /^(?:\s*,\s*|\s+(?:and|&)\s+)/i;
 
+// A run of issue refs ("#1, #2 and owner/repo#3") starting at the head of `segment`.
+// Bare refs resolve against `fallbackDefaultRepo`; unresolvable ones are skipped so a
+// land never fails here.
+function collectRefRun(segment: string, fallbackDefaultRepo: string | undefined, into: IssueRef[]): void {
+  let rest = segment;
+  while (rest.trim()) {
+    rest = rest.trimStart();
+    const refMatch = rest.match(ISSUE_REF_AT_START_RE);
+    if (!refMatch) break;
+    try {
+      into.push(resolveIssueRefFromString({ ref: refMatch[1]!, defaultRepo: fallbackDefaultRepo }));
+    } catch {
+      // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
+    }
+    rest = rest.slice(refMatch[0].length);
+    const separator = rest.match(REF_SEPARATOR_RE);
+    if (!separator) break;
+    rest = rest.slice(separator[0].length);
+  }
+}
+
 export function parseClosingIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
   if (!text) return [];
   const refs: IssueRef[] = [];
-  for (const match of text.matchAll(CLOSING_KEYWORD_RE)) {
-    let rest = match[1] ?? "";
-    while (rest.trim()) {
-      rest = rest.trimStart();
-      const refMatch = rest.match(ISSUE_REF_AT_START_RE);
-      if (!refMatch) break;
-      try {
-        refs.push(resolveIssueRefFromString({ ref: refMatch[1]!, defaultRepo: fallbackDefaultRepo }));
-      } catch {
-        // Invalid or bare-without-default refs are ignored; the land itself must never fail here.
-      }
-      rest = rest.slice(refMatch[0].length);
-      const separator = rest.match(REF_SEPARATOR_RE);
-      if (!separator) break;
-      rest = rest.slice(separator[0].length);
-    }
-  }
+  for (const match of text.matchAll(CLOSING_KEYWORD_RE)) collectRefRun(match[1] ?? "", fallbackDefaultRepo, refs);
+  return issueRefMap(refs);
+}
+
+// Parenthesized backlink groups: the trailing `(#NNN)` convention agents (and a squash merge)
+// stamp on a subject without a closing keyword. Non-issue parens (conventional-commit scopes
+// like `fix(tokens)`, notes like `(see also)`) carry no `#` and fall out.
+const BACKLINK_GROUP_RE = /\(([^()]*#[0-9]+[^()]*)\)/g;
+
+export function parseBacklinkIssueRefs(text: string | undefined, fallbackDefaultRepo = defaultIssueRepo()): IssueRef[] {
+  if (!text) return [];
+  const refs: IssueRef[] = [];
+  for (const group of text.matchAll(BACKLINK_GROUP_RE)) collectRefRun(group[1] ?? "", fallbackDefaultRepo, refs);
   return issueRefMap(refs);
 }
 
-export function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: "association" | "commit"; refs: IssueRef[] } {
+export function resolveIssueRefsForLand(input: LandedIssueLifecycleInput): { source: LandIssueRefSource; refs: IssueRef[] } {
   const associated = associatedIssueRefs(input.workspace);
   if (associated.length > 0) return { source: "association", refs: associated };
-  return { source: "commit", refs: parseClosingIssueRefs(input.subject) };
+  const fallbackDefaultRepo = landDefaultRepo(input.workspace);
+  const keyworded = parseClosingIssueRefs(input.subject, fallbackDefaultRepo);
+  if (keyworded.length > 0) return { source: "commit", refs: keyworded };
+  // Bare `(#NNN)` is closing intent in relay-land mode (no PR), but the SAME shape is the
+  // PR number GitHub appends to a squash subject — never close that. Suppress on PR lands;
+  // those rely on GitHub-native keywords + durable association instead (#482).
+  if (input.prLand) return { source: "commit", refs: [] };
+  return { source: "backlink", refs: parseBacklinkIssueRefs(input.subject, fallbackDefaultRepo) };
 }
 
 function closeAuditComment(input: LandedIssueLifecycleInput): string {
@@ -152,7 +230,7 @@ function closeAuditComment(input: LandedIssueLifecycleInput): string {
 
 async function closeIssueRefForLand(
   issueRef: IssueRef,
-  source: "association" | "commit",
+  source: LandIssueRefSource,
   input: LandedIssueLifecycleInput,
   opts: IssueLifecycleOptions,
 ): Promise<CloseIssueLifecycleResult> {
@@ -237,7 +315,7 @@ async function reopenIssuesForRevert(input: LandedIssueLifecycleInput, opts: Iss
 }
 
 export async function handleLandedIssueLifecycle(input: LandedIssueLifecycleInput, opts: IssueLifecycleOptions = {}): Promise<{
-  source: "association" | "commit";
+  source: LandIssueRefSource;
   closed: CloseIssueLifecycleResult[];
   reopened: ReopenIssueLifecycleResult[];
   skipped: string[];