perf(issue): skip getProject round-trip in project-search resolution

resolveProjectSearch() was calling findProjectsBySlug() (which does
getProject per org) then getIssueByShortId() sequentially. The shortid
endpoint already validates project existence, so the getProject call is
redundant.

Now tries tryGetIssueByShortId() directly across all orgs in parallel,
eliminating one HTTP round-trip (~500-800ms). Falls back to
findProjectsBySlug() only for error diagnostics.

Fixes https://sentry.sentry.io/issues/7340600304/

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: betegon

src/commands/issue/utils.ts

@@ -12,12 +12,19 @@ import {
   getIssueInOrg,
   type IssueSort,
   listIssuesPaginated,
+  listOrganizations,
   triggerRootCauseAnalysis,
+  tryGetIssueByShortId,
 } from "../../lib/api-client.js";
 import { type IssueSelector, parseIssueArg } from "../../lib/arg-parsing.js";
 import { getProjectByAlias } from "../../lib/db/project-aliases.js";
 import { detectAllDsns } from "../../lib/dsn/index.js";
-import { ApiError, ContextError, ResolutionError } from "../../lib/errors.js";
+import {
+  ApiError,
+  ContextError,
+  ResolutionError,
+  withAuthGuard,
+} from "../../lib/errors.js";
 import { getProgressMessage } from "../../lib/formatters/seer.js";
 import { expandToFullShortId, isShortSuffix } from "../../lib/issue-id.js";
 import { logger } from "../../lib/logger.js";
@@ -173,7 +180,46 @@ async function resolveProjectSearch(
     return { org: dsnTarget.org, issue };
   }
 
-  // 3. Search for project across all accessible orgs
+  // 3. Fast path: try resolving the short ID directly across all orgs.
+  //    The shortid endpoint validates both project existence and issue existence
+  //    in a single call, eliminating the separate getProject() round-trip.
+  const fullShortId = expandToFullShortId(suffix, projectSlug);
+  const orgs = await listOrganizations();
+
+  const results = await Promise.all(
+    orgs.map((org) =>
+      withAuthGuard(() => tryGetIssueByShortId(org.slug, fullShortId))
+    )
+  );
+
+  const successes: StrictResolvedIssue[] = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const org = orgs[i];
+    if (result && org && result.ok && result.value) {
+      successes.push({ org: org.slug, issue: result.value });
+    }
+  }
+
+  if (successes.length === 1 && successes[0]) {
+    return successes[0];
+  }
+
+  if (successes.length > 1) {
+    const orgList = successes.map((s) => s.org).join(", ");
+    throw new ResolutionError(
+      `Project '${projectSlug}'`,
+      "is ambiguous",
+      commandHint,
+      [
+        `Found in: ${orgList}`,
+        `Specify the org: sentry issue ... <org>/${projectSlug}-${suffix}`,
+      ]
+    );
+  }
+
+  // 4. All orgs returned 404 — fall back to findProjectsBySlug for a
+  //    precise error: "project not found" vs "issue not found in project".
   const { projects } = await findProjectsBySlug(projectSlug.toLowerCase());
 
   if (projects.length === 0) {
@@ -198,18 +244,15 @@ async function resolveProjectSearch(
     );
   }
 
-  const project = projects[0];
-  if (!project) {
-    throw new ResolutionError(
-      `Project '${projectSlug}'`,
-      "not found",
-      commandHint
-    );
-  }
-
-  const fullShortId = expandToFullShortId(suffix, project.slug);
-  const issue = await getIssueByShortId(project.orgSlug, fullShortId);
-  return { org: project.orgSlug, issue };
+  // Project exists but issue doesn't
+  throw new ResolutionError(
+    `Issue '${fullShortId}'`,
+    "not found",
+    commandHint,
+    [
+      `Project '${projectSlug}' exists in org '${projects[0]?.orgSlug}', but no issue with short ID '${fullShortId}' was found.`,
+    ]
+  );
 }
 
 /**

src/lib/api-client.ts

@@ -49,6 +49,7 @@ export {
   type IssuesPage,
   listIssuesAllPages,
   listIssuesPaginated,
+  tryGetIssueByShortId,
   updateIssueStatus,
 } from "./api/issues.js";
 export {

src/lib/api/issues.ts

@@ -251,6 +251,31 @@ export async function getIssueByShortId(
   return resolved.group;
 }
 
+/**
+ * Try to get an issue by short ID, returning null on 404.
+ *
+ * Same as {@link getIssueByShortId} but returns null instead of throwing
+ * when the short ID is not found. Useful for parallel fan-out across orgs
+ * where most will 404.
+ *
+ * @param orgSlug - Organization slug
+ * @param shortId - Full short ID (e.g., "CONSUMER-MOBILE-1QNEK")
+ * @returns The resolved issue, or null if not found in this org
+ */
+export async function tryGetIssueByShortId(
+  orgSlug: string,
+  shortId: string
+): Promise<SentryIssue | null> {
+  try {
+    return await getIssueByShortId(orgSlug, shortId);
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404) {
+      return null;
+    }
+    throw error;
+  }
+}
+
 /**
  * Update an issue's status.
  */