Auto-attach pasted GitHub PR/issue URLs in the composer (#1006)

* Auto-attach pasted GitHub PR/issue URLs in the composer

Paste a GitHub PR or issue link into any composer and it shows up
as an attachment pill within a debounce tick when the URL matches
the workspace's remote. On the new-workspace screen, an attached PR
also surfaces an inline "Check out PR #N?" hint next to the picker;
one click promotes it to the checkout target through the same
syncPickerPrAttachment flow the dropdown uses.

Unifies the new-workspace picker and composer attachment picker on
one shared GitHub search hook and cache key, so both consumers (and
the auto-attach lookup) share the React Query cache.

* Fix oxfmt formatting in new-workspace-screen import

packages/app/src/components/composer-actions.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { AgentAttachment, GitHubSearchItem } from "@server/shared/messages";
 import type {
   AttachmentMetadata,
@@ -19,6 +19,7 @@ import {
   removeComposerAttachmentAtIndex,
   sendQueuedComposerMessageNow,
   toggleGithubAttachment,
+  toggleGithubAttachmentFromPicker,
   type AgentStreamWriter,
   type AttachmentPersister,
   type ComposerCancelClient,
@@ -696,6 +697,36 @@ describe("toggleGithubAttachment", () => {
   });
 });
 
+describe("toggleGithubAttachmentFromPicker", () => {
+  it("marks an existing GitHub item as removed when picker toggle removes it", () => {
+    const markGithubAttachmentRemoved = vi.fn();
+    const attachment: UserComposerAttachment = { kind: "github_pr", item: prItem };
+
+    const next = toggleGithubAttachmentFromPicker({
+      current: [attachment],
+      item: prItem,
+      markGithubAttachmentRemoved,
+    });
+
+    expect(next).toEqual([]);
+    expect(markGithubAttachmentRemoved).toHaveBeenCalledTimes(1);
+    expect(markGithubAttachmentRemoved).toHaveBeenCalledWith(attachment);
+  });
+
+  it("does not mark a GitHub item removed when picker toggle adds it", () => {
+    const markGithubAttachmentRemoved = vi.fn();
+
+    const next = toggleGithubAttachmentFromPicker({
+      current: [],
+      item: issueItem,
+      markGithubAttachmentRemoved,
+    });
+
+    expect(next).toEqual([{ kind: "github_issue", item: issueItem }]);
+    expect(markGithubAttachmentRemoved).not.toHaveBeenCalled();
+  });
+});
+
 describe("findGithubItemByOption / isAttachmentSelectedForGithubItem", () => {
   it("locates items via their composite kind:number id", () => {
     expect(findGithubItemByOption([issueItem, prItem], "issue:101")).toBe(issueItem);

packages/app/src/components/composer-actions.ts

@@ -305,6 +305,29 @@ export function toggleGithubAttachment(
   return [...current, buildGithubAttachment(item)];
 }
 
+interface ToggleGithubAttachmentFromPickerInput {
+  current: UserComposerAttachment[];
+  item: GitHubSearchItem;
+  markGithubAttachmentRemoved: (attachment: UserComposerAttachment) => void;
+}
+
+export function toggleGithubAttachmentFromPicker({
+  current,
+  item,
+  markGithubAttachmentRemoved,
+}: ToggleGithubAttachmentFromPickerInput): UserComposerAttachment[] {
+  const existingAttachment = current.find(
+    (attachment) =>
+      attachment.kind !== "image" &&
+      attachment.item.kind === item.kind &&
+      attachment.item.number === item.number,
+  );
+  if (existingAttachment) {
+    markGithubAttachmentRemoved(existingAttachment);
+  }
+  return toggleGithubAttachment(current, item);
+}
+
 export function findGithubItemByOption(
   items: readonly GitHubSearchItem[],
   optionId: string,

packages/app/src/components/composer.tsx

@@ -21,7 +21,6 @@ import {
   Paperclip,
 } from "lucide-react-native";
 import Animated from "react-native-reanimated";
-import { useQuery } from "@tanstack/react-query";
 import { FOOTER_HEIGHT, MAX_CONTENT_WIDTH } from "@/constants/layout";
 import {
   AgentStatusBar,
@@ -53,7 +52,7 @@ import {
   queueComposerMessage,
   removeComposerAttachmentAtIndex,
   sendQueuedComposerMessageNow,
-  toggleGithubAttachment,
+  toggleGithubAttachmentFromPicker,
   type AgentStreamWriter,
   type QueueWriter,
   type QueuedComposerMessage,
@@ -97,6 +96,9 @@ import { AttachmentPill } from "@/components/attachment-pill";
 import { AttachmentLightbox } from "@/components/attachment-lightbox";
 import { openExternalUrl } from "@/utils/open-external-url";
 import { useIsDictationReady } from "@/hooks/use-is-dictation-ready";
+import { useGithubSearchQuery } from "@/git/use-github-search-query";
+import { useCheckoutStatusQuery } from "@/git/use-status-query";
+import { useComposerGithubAutoAttach } from "./use-composer-github-auto-attach";
 
 type QueuedMessage = QueuedComposerMessage;
 
@@ -137,6 +139,20 @@ function resolveMessagePlaceholder(isDesktopWebBreakpoint: boolean): string {
   return isDesktopWebBreakpoint ? DESKTOP_MESSAGE_PLACEHOLDER : MOBILE_MESSAGE_PLACEHOLDER;
 }
 
+function resolveGithubSearchEnabled(
+  isGithubPickerOpen: boolean,
+  isConnected: boolean,
+  cwd: string,
+): boolean {
+  return isGithubPickerOpen && isConnected && cwd.trim().length > 0;
+}
+
+function resolveCheckoutRemoteUrl(
+  checkoutStatus: ReturnType<typeof useCheckoutStatusQuery>["status"],
+): string | null {
+  return checkoutStatus?.remoteUrl ?? null;
+}
+
 function buildCancelButtonStyle(isConnected: boolean, isCancellingAgent: boolean): object[] {
   const disabled = !isConnected || isCancellingAgent ? styles.buttonDisabled : undefined;
   return [styles.cancelButton, disabled].filter((value): value is object => Boolean(value));
@@ -164,31 +180,6 @@ function buildAgentStateSelector(serverId: string, agentId: string) {
   };
 }
 
-interface BuildGithubSearchQueryOptionsArgs {
-  serverId: string;
-  cwd: string;
-  githubSearchQueryTrimmed: string;
-  isGithubPickerOpen: boolean;
-  isConnected: boolean;
-  client: ReturnType<typeof useHostRuntimeClient>;
-}
-
-function buildGithubSearchQueryOptions(args: BuildGithubSearchQueryOptionsArgs) {
-  const { serverId, cwd, githubSearchQueryTrimmed, isGithubPickerOpen, isConnected, client } = args;
-  const hasClient = Boolean(client);
-  const cwdIsSet = cwd.trim().length > 0;
-  const enabled = isGithubPickerOpen && isConnected && hasClient && cwdIsSet;
-  return {
-    queryKey: ["composer-github-search", serverId, cwd, githubSearchQueryTrimmed],
-    queryFn: async () => {
-      if (!client) throw new Error("Host is not connected");
-      return client.searchGitHub({ cwd, query: githubSearchQueryTrimmed, limit: 20 });
-    },
-    enabled,
-    staleTime: 30_000,
-  };
-}
-
 function renderContextWindowMeterSlot(
   contextWindowMaxTokens: number | null,
   contextWindowUsedTokens: number | null,
@@ -890,6 +881,17 @@ export function Composer({
     onOpenWorkspaceAttachment,
   });
   const setSelectedAttachments = onChangeAttachments;
+  const checkoutStatusQuery = useCheckoutStatusQuery({ serverId, cwd });
+  const githubAutoAttach = useComposerGithubAutoAttach({
+    text: userInput,
+    remoteUrl: resolveCheckoutRemoteUrl(checkoutStatusQuery.status),
+    attachments,
+    client,
+    isConnected,
+    serverId,
+    cwd,
+    setAttachments: setSelectedAttachments,
+  });
   const [cursorIndex, setCursorIndex] = useState(0);
   const [isProcessing, setIsProcessing] = useState(false);
   const [isCancellingAgent, setIsCancellingAgent] = useState(false);
@@ -1135,6 +1137,7 @@ export function Composer({
 
   const handleRemoveAttachment = useCallback(
     (index: number) => {
+      githubAutoAttach.markGithubAttachmentRemoved(selectedAttachments[index]);
       const didRemoveWorkspaceAttachment = removeAttachment({
         selectedAttachments,
         index,
@@ -1146,7 +1149,7 @@ export function Composer({
         removeComposerAttachmentAtIndex({ attachments: prev, index, deleteAttachments }),
       );
     },
-    [removeAttachment, selectedAttachments, setSelectedAttachments],
+    [githubAutoAttach, removeAttachment, selectedAttachments, setSelectedAttachments],
   );
 
   const handleOpenAttachment = useCallback(
@@ -1376,16 +1379,13 @@ export function Composer({
   );
 
   const githubSearchQueryTrimmed = githubSearchQuery.trim();
-  const githubSearchResultsQuery = useQuery(
-    buildGithubSearchQueryOptions({
-      serverId,
-      cwd,
-      githubSearchQueryTrimmed,
-      isGithubPickerOpen,
-      isConnected,
-      client,
-    }),
-  );
+  const githubSearchResultsQuery = useGithubSearchQuery({
+    client,
+    serverId,
+    cwd,
+    query: githubSearchQueryTrimmed,
+    enabled: resolveGithubSearchEnabled(isGithubPickerOpen, isConnected, cwd),
+  });
 
   const githubSearchItemsRaw = githubSearchResultsQuery.data?.items;
   const githubSearchItems = useMemo(() => githubSearchItemsRaw ?? [], [githubSearchItemsRaw]);
@@ -1423,11 +1423,22 @@ export function Composer({
 
   const handleToggleGithubItem = useCallback(
     (item: GitHubSearchItem) => {
-      setSelectedAttachments((current) => toggleGithubAttachment(current, item));
+      const nextAttachments = toggleGithubAttachmentFromPicker({
+        current: attachments,
+        item,
+        markGithubAttachmentRemoved: githubAutoAttach.markGithubAttachmentRemoved,
+      });
+      setSelectedAttachments(nextAttachments);
       setIsGithubPickerOpen(false);
       setGithubSearchQuery("");
     },
-    [setSelectedAttachments, setGithubSearchQuery, setIsGithubPickerOpen],
+    [
+      attachments,
+      githubAutoAttach,
+      setSelectedAttachments,
+      setGithubSearchQuery,
+      setIsGithubPickerOpen,
+    ],
   );
 
   const leftContent = useMemo(

packages/app/src/components/use-composer-github-auto-attach.test.tsx

@@ -0,0 +1,213 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act, renderHook } from "@testing-library/react";
+import React, { type ReactNode } from "react";
+import { useState } from "react";
+import { describe, expect, it, vi } from "vitest";
+import type { UserComposerAttachment } from "@/attachments/types";
+import type { GitHubSearchClient } from "@/git/use-github-search-query";
+import type { GitHubSearchItem, GitHubSearchResponse } from "@server/shared/messages";
+import { useComposerGithubAutoAttach } from "./use-composer-github-auto-attach";
+
+type GitHubSearchPayload = GitHubSearchResponse["payload"];
+
+const remoteUrl = "git@github.com:acme/paseo.git";
+const cwd = "/repo";
+
+const pr101: GitHubSearchItem = {
+  kind: "pr",
+  number: 101,
+  title: "Attach PR",
+  url: "https://github.com/acme/paseo/pull/101",
+  state: "open",
+  body: null,
+  labels: [],
+  baseRefName: "main",
+  headRefName: "feature",
+};
+
+const issue202: GitHubSearchItem = {
+  kind: "issue",
+  number: 202,
+  title: "Attach issue",
+  url: "https://github.com/acme/paseo/issues/202",
+  state: "open",
+  body: null,
+  labels: [],
+  baseRefName: null,
+  headRefName: null,
+};
+
+interface SearchCall {
+  cwd: string;
+  query: string;
+  limit?: number;
+}
+
+interface HarnessInput {
+  initialAttachments?: UserComposerAttachment[];
+  initialText?: string;
+  remote?: string | null;
+}
+
+function githubPayload(items: GitHubSearchItem[], requestId: string): GitHubSearchPayload {
+  return {
+    items,
+    githubFeaturesEnabled: true,
+    error: null,
+    requestId,
+  };
+}
+
+function createSearchClient(
+  items: GitHubSearchItem[],
+): GitHubSearchClient & { calls: SearchCall[] } {
+  const calls: SearchCall[] = [];
+  return {
+    calls,
+    async searchGitHub(options) {
+      calls.push(options);
+      return githubPayload(items, `search-${options.query}`);
+    },
+  };
+}
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+  };
+}
+
+function useHarness(client: GitHubSearchClient, input: HarnessInput = {}) {
+  const [text, setText] = useState(input.initialText ?? "");
+  const [attachments, setAttachments] = useState<UserComposerAttachment[]>(
+    input.initialAttachments ?? [],
+  );
+  const autoAttach = useComposerGithubAutoAttach({
+    text,
+    remoteUrl: input.remote ?? remoteUrl,
+    attachments,
+    client,
+    isConnected: true,
+    serverId: "server-1",
+    cwd,
+    setAttachments,
+  });
+
+  return {
+    text,
+    setText,
+    attachments,
+    setAttachments,
+    markGithubAttachmentRemoved: autoAttach.markGithubAttachmentRemoved,
+  };
+}
+
+async function flushDebounce() {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(300);
+    await Promise.resolve();
+  });
+}
+
+describe("useComposerGithubAutoAttach", () => {
+  it("adds a matching pasted GitHub PR URL as a composer attachment", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText("Please review https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([{ kind: "github_pr", item: pr101 }]);
+    expect(client.calls).toEqual([{ cwd, query: "101", limit: 20 }]);
+    vi.useRealTimers();
+  });
+
+  it("ignores URLs that do not match the current remote", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText("Other repo https://github.com/other/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([]);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("does not add a second pill when the ref is already attached", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const initialAttachments: UserComposerAttachment[] = [{ kind: "github_pr", item: pr101 }];
+    const { result } = renderHook(() => useHarness(client, { initialAttachments }), {
+      wrapper: createWrapper(),
+    });
+
+    act(() => {
+      result.current.setText("Already here https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual(initialAttachments);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("does not re-add a GitHub ref removed earlier in the same composer session", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const initialAttachments: UserComposerAttachment[] = [{ kind: "github_pr", item: pr101 }];
+    const { result } = renderHook(() => useHarness(client, { initialAttachments }), {
+      wrapper: createWrapper(),
+    });
+
+    act(() => {
+      result.current.markGithubAttachmentRemoved(initialAttachments[0]);
+      result.current.setAttachments([]);
+      result.current.setText("Re-pasted https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([]);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("handles multiple matching URLs from one paste", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101, issue202]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText(
+        "Refs https://github.com/acme/paseo/pull/101 and https://github.com/acme/paseo/issues/202",
+      );
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([
+      { kind: "github_pr", item: pr101 },
+      { kind: "github_issue", item: issue202 },
+    ]);
+    expect(client.calls).toEqual([
+      { cwd, query: "101", limit: 20 },
+      { cwd, query: "202", limit: 20 },
+    ]);
+    vi.useRealTimers();
+  });
+});

packages/app/src/components/use-composer-github-auto-attach.ts

@@ -0,0 +1,240 @@
+import { useQueryClient, type QueryClient } from "@tanstack/react-query";
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  type Dispatch,
+  type RefObject,
+  type SetStateAction,
+} from "react";
+import type { ComposerAttachment, UserComposerAttachment } from "@/attachments/types";
+import {
+  buildGithubSearchQueryOptions,
+  type GitHubSearchClient,
+} from "@/git/use-github-search-query";
+import { extractGithubRefs, type GithubRef } from "@/utils/github-refs";
+import type { GitHubSearchItem } from "@server/shared/messages";
+import { isAttachmentSelectedForGithubItem, toggleGithubAttachment } from "./composer-actions";
+
+const AUTO_ATTACH_DEBOUNCE_MS = 300;
+
+interface ComposerGithubAutoAttachInput {
+  text: string;
+  remoteUrl: string | null | undefined;
+  attachments: UserComposerAttachment[];
+  client: GitHubSearchClient | null;
+  isConnected: boolean;
+  serverId: string;
+  cwd: string;
+  setAttachments: Dispatch<SetStateAction<UserComposerAttachment[]>>;
+}
+
+interface ComposerGithubAutoAttachResult {
+  markGithubAttachmentRemoved: (attachment: ComposerAttachment | undefined) => void;
+}
+
+export function useComposerGithubAutoAttach(
+  params: ComposerGithubAutoAttachInput,
+): ComposerGithubAutoAttachResult {
+  const queryClient = useQueryClient();
+  const latestRef = useRef(params);
+  const removedRefKeysRef = useRef(new Set<string>());
+  const pendingRefKeysRef = useRef(new Set<string>());
+
+  latestRef.current = params;
+
+  useEffect(() => {
+    const refs = refsReadyForLookup({
+      params: latestRef.current,
+      removedRefKeys: removedRefKeysRef.current,
+      pendingRefKeys: pendingRefKeysRef.current,
+    });
+    if (refs.length === 0) {
+      return;
+    }
+
+    const timerId = setTimeout(() => {
+      void attachRefs({
+        refs,
+        queryClient,
+        latestRef,
+        removedRefKeys: removedRefKeysRef.current,
+        pendingRefKeys: pendingRefKeysRef.current,
+      });
+    }, AUTO_ATTACH_DEBOUNCE_MS);
+
+    return () => {
+      clearTimeout(timerId);
+    };
+  }, [
+    params.text,
+    params.remoteUrl,
+    params.attachments,
+    params.client,
+    params.isConnected,
+    params.serverId,
+    params.cwd,
+    queryClient,
+  ]);
+
+  const markGithubAttachmentRemoved = useCallback((attachment: ComposerAttachment | undefined) => {
+    const key = attachmentKey(attachment);
+    if (key) {
+      removedRefKeysRef.current.add(key);
+    }
+  }, []);
+
+  return useMemo(
+    () => ({
+      markGithubAttachmentRemoved,
+    }),
+    [markGithubAttachmentRemoved],
+  );
+}
+
+async function attachRefs({
+  refs,
+  queryClient,
+  latestRef,
+  removedRefKeys,
+  pendingRefKeys,
+}: {
+  refs: GithubRef[];
+  queryClient: QueryClient;
+  latestRef: RefObject<ComposerGithubAutoAttachInput>;
+  removedRefKeys: Set<string>;
+  pendingRefKeys: Set<string>;
+}): Promise<void> {
+  for (const ref of refs) {
+    const key = githubRefKey(ref);
+    if (pendingRefKeys.has(key)) {
+      continue;
+    }
+    pendingRefKeys.add(key);
+    try {
+      await attachRef({ ref, key, queryClient, latestRef, removedRefKeys });
+    } finally {
+      pendingRefKeys.delete(key);
+    }
+  }
+}
+
+async function attachRef({
+  ref,
+  key,
+  queryClient,
+  latestRef,
+  removedRefKeys,
+}: {
+  ref: GithubRef;
+  key: string;
+  queryClient: QueryClient;
+  latestRef: RefObject<ComposerGithubAutoAttachInput>;
+  removedRefKeys: Set<string>;
+}): Promise<void> {
+  const snapshot = latestRef.current;
+  if (!snapshot.client || !snapshot.isConnected || !isRefStillPresent(ref, snapshot)) {
+    return;
+  }
+
+  const search = await fetchGithubRefSearch({ ref, snapshot, queryClient });
+  if (!search) {
+    return;
+  }
+  const item = search.items.find((candidate) => githubItemMatchesRef(candidate, ref));
+  if (!item || removedRefKeys.has(key) || !isRefStillPresent(ref, latestRef.current)) {
+    return;
+  }
+
+  latestRef.current.setAttachments((current) => {
+    if (removedRefKeys.has(key) || isAttachmentSelectedForGithubItem(current, item)) {
+      return current;
+    }
+    return toggleGithubAttachment(current, item);
+  });
+}
+
+function refsReadyForLookup({
+  params,
+  removedRefKeys,
+  pendingRefKeys,
+}: {
+  params: ComposerGithubAutoAttachInput;
+  removedRefKeys: Set<string>;
+  pendingRefKeys: Set<string>;
+}): GithubRef[] {
+  if (!params.client || !params.isConnected || params.cwd.trim().length === 0) {
+    return [];
+  }
+
+  return extractGithubRefs(params.text, params.remoteUrl).filter((ref) => {
+    const key = githubRefKey(ref);
+    return (
+      !removedRefKeys.has(key) &&
+      !pendingRefKeys.has(key) &&
+      !hasGithubAttachment(params.attachments, ref)
+    );
+  });
+}
+
+async function fetchGithubRefSearch({
+  ref,
+  snapshot,
+  queryClient,
+}: {
+  ref: GithubRef;
+  snapshot: ComposerGithubAutoAttachInput;
+  queryClient: QueryClient;
+}) {
+  if (!snapshot.client) {
+    return null;
+  }
+
+  try {
+    return await queryClient.fetchQuery(
+      buildGithubSearchQueryOptions({
+        client: snapshot.client,
+        serverId: snapshot.serverId,
+        cwd: snapshot.cwd,
+        query: String(ref.number),
+        enabled: true,
+      }),
+    );
+  } catch {
+    return null;
+  }
+}
+
+function isRefStillPresent(ref: GithubRef, params: ComposerGithubAutoAttachInput): boolean {
+  return extractGithubRefs(params.text, params.remoteUrl).some(
+    (candidate) => githubRefKey(candidate) === githubRefKey(ref),
+  );
+}
+
+function hasGithubAttachment(attachments: UserComposerAttachment[], ref: GithubRef): boolean {
+  return attachments.some((attachment) => attachmentKey(attachment) === githubRefKey(ref));
+}
+
+function githubItemMatchesRef(item: GitHubSearchItem, ref: GithubRef): boolean {
+  return item.kind === githubItemKind(ref) && item.number === ref.number;
+}
+
+function githubItemKind(ref: GithubRef): GitHubSearchItem["kind"] {
+  return ref.kind === "pull" ? "pr" : "issue";
+}
+
+function githubRefKey(ref: GithubRef): string {
+  return `${githubItemKind(ref)}:${ref.number}`;
+}
+
+function attachmentKey(attachment: ComposerAttachment | undefined): string | null {
+  if (
+    !attachment ||
+    attachment.kind === "image" ||
+    (attachment.kind !== "github_pr" && attachment.kind !== "github_issue")
+  ) {
+    return null;
+  }
+  return `${attachment.item.kind}:${attachment.item.number}`;
+}