refactor(list): extract compound cursor and target resolution to shared lib

Moves duplicated code from issue/list.ts and alert/issues/list.ts into
shared modules so both commands use the same implementation:

- lib/db/pagination.ts: exports CURSOR_SEP, encodeCompoundCursor,
  decodeCompoundCursor, buildMultiTargetContextKey
- lib/resolve-target.ts: exports resolveTargetsFromParsedArg — handles all
  four target modes (auto-detect, explicit, org-all, project-search) with
  options for enrichProjectIds and checkIssueShortId (issue-list-specific)

issue/list.ts drops ~260 lines of local duplicates; alert/issues/list.ts
never needs to define them in the first place.

Author: betegon

src/commands/issue/list.ts

@@ -10,24 +10,20 @@ import { buildOrgAwareAliases } from "../../lib/alias.js";
 import {
   API_MAX_PER_PAGE,
   buildIssueListCollapse,
-  findProjectsByPattern,
-  findProjectsBySlug,
-  getProject,
   type IssueCollapseField,
   type IssuesPage,
   listIssuesAllPages,
   listIssuesPaginated,
-  listProjects,
 } from "../../lib/api-client.js";
-import {
-  looksLikeIssueShortId,
-  parseOrgProjectArg,
-} from "../../lib/arg-parsing.js";
+import { parseOrgProjectArg } from "../../lib/arg-parsing.js";
 import { getActiveEnvVarName, isEnvTokenActive } from "../../lib/db/auth.js";
 import {
   advancePaginationState,
+  buildMultiTargetContextKey,
   buildPaginationContextKey,
-  escapeContextKeyValue,
+  CURSOR_SEP,
+  decodeCompoundCursor,
+  encodeCompoundCursor,
   hasPreviousPage,
   resolveCursor,
 } from "../../lib/db/pagination.js";
@@ -39,7 +35,6 @@ import { createDsnFingerprint } from "../../lib/dsn/index.js";
 import {
   ApiError,
   ContextError,
-  ResolutionError,
   ValidationError,
   withAuthGuard,
 } from "../../lib/errors.js";
@@ -72,13 +67,9 @@ import {
 } from "../../lib/org-list.js";
 import { withProgress } from "../../lib/polling.js";
 import {
-  fetchProjectId,
   type ResolvedTarget,
-  resolveAllTargets,
-  toNumericId,
+  resolveTargetsFromParsedArg,
 } from "../../lib/resolve-target.js";
-import { getApiBaseUrl } from "../../lib/sentry-client.js";
-import { setOrgProjectContext } from "../../lib/telemetry.js";
 import type {
   ProjectAliasEntry,
   SentryIssue,
@@ -346,191 +337,6 @@ type FetchResult =
   | { success: true; data: IssueListFetchResult }
   | { success: false; error: Error };
 
-/** Result of resolving targets from parsed argument */
-type TargetResolutionResult = {
-  targets: ResolvedTarget[];
-  footer?: string;
-  skippedSelfHosted?: number;
-  detectedDsns?: import("../../lib/dsn/index.js").DetectedDsn[];
-};
-
-/**
- * Resolve targets based on parsed org/project argument.
- *
- * Handles all four cases:
- * - auto-detect: Use DSN detection / config defaults
- * - explicit: Single org/project target
- * - org-all: All projects in specified org
- * - project-search: Find project across all orgs
- */
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: inherent multi-mode target resolution with per-mode error handling
-async function resolveTargetsFromParsedArg(
-  parsed: ReturnType<typeof parseOrgProjectArg>,
-  cwd: string
-): Promise<TargetResolutionResult> {
-  switch (parsed.type) {
-    case "auto-detect": {
-      // Use existing resolution logic (DSN detection, config defaults)
-      const result = await resolveAllTargets({ cwd, usageHint: USAGE_HINT });
-      // DSN-detected and directory-inferred targets already carry a projectId.
-      // Env var / config-default paths return targets without one, so enrich
-      // them now using the project API. Any failure silently falls back to
-      // slug-based querying — the target was already resolved, so we never
-      // surface a ResolutionError here (that's only for the explicit case).
-      result.targets = await Promise.all(
-        result.targets.map(async (t) => {
-          if (t.projectId !== undefined) {
-            return t;
-          }
-          try {
-            const info = await getProject(t.org, t.project);
-            const id = toNumericId(info.id);
-            return id !== undefined ? { ...t, projectId: id } : t;
-          } catch {
-            return t;
-          }
-        })
-      );
-      return result;
-    }
-
-    case "explicit": {
-      // Single explicit target — fetch project ID for API query param
-      // Telemetry context is set by dispatchOrgScopedList before this handler runs.
-      const projectId = await fetchProjectId(parsed.org, parsed.project);
-      return {
-        targets: [
-          {
-            org: parsed.org,
-            project: parsed.project,
-            projectId,
-            orgDisplay: parsed.org,
-            projectDisplay: parsed.project,
-          },
-        ],
-      };
-    }
-
-    case "org-all": {
-      // List all projects in the specified org
-      // Telemetry context is set by dispatchOrgScopedList before this handler runs.
-      const projects = await listProjects(parsed.org);
-      const targets: ResolvedTarget[] = projects.map((p) => ({
-        org: parsed.org,
-        project: p.slug,
-        projectId: toNumericId(p.id),
-        orgDisplay: parsed.org,
-        projectDisplay: p.name,
-      }));
-
-      if (targets.length === 0) {
-        throw new ResolutionError(
-          `Organization '${parsed.org}'`,
-          "has no accessible projects",
-          `sentry project list ${parsed.org}/`,
-          ["Check that you have access to projects in this organization"]
-        );
-      }
-
-      return {
-        targets,
-        footer:
-          targets.length > 1
-            ? `Showing issues from ${targets.length} projects in ${parsed.org}`
-            : undefined,
-      };
-    }
-
-    case "project-search": {
-      // Detect when user passes an issue short ID instead of a project slug.
-      // Short IDs like "CONVERSATION-SVC-F" or "CLI-BM" are all-uppercase
-      // with a dash-separated suffix — a pattern that never occurs in project
-      // slugs (which are always lowercase).
-      if (looksLikeIssueShortId(parsed.projectSlug)) {
-        throw new ResolutionError(
-          `'${parsed.projectSlug}'`,
-          "looks like an issue short ID, not a project slug",
-          `sentry issue view ${parsed.projectSlug}`,
-          ["To list issues in a project: sentry issue list <org>/<project>"]
-        );
-      }
-
-      // Find project across all orgs
-      const { projects: matches, orgs } = await findProjectsBySlug(
-        parsed.projectSlug
-      );
-
-      if (matches.length === 0) {
-        // Check if the slug matches an organization — common mistake.
-        // The orgSlugMatchBehavior: "redirect" pre-check handles this for
-        // cached orgs (hot path). This is the cold-cache fallback: org
-        // isn't cached yet, so the pre-check couldn't fire. We throw a
-        // ResolutionError with a hint — after this command, the org will
-        // be cached and future runs will auto-redirect.
-        const isOrg = orgs.some((o) => o.slug === parsed.projectSlug);
-        if (isOrg) {
-          throw new ResolutionError(
-            `'${parsed.projectSlug}'`,
-            "is an organization, not a project",
-            `sentry issue list ${parsed.projectSlug}/`,
-            [
-              `List projects: sentry project list ${parsed.projectSlug}/`,
-              `Specify a project: sentry issue list ${parsed.projectSlug}/<project>`,
-            ]
-          );
-        }
-
-        // Try word-boundary matching to suggest similar projects (CLI-A4, 16 users).
-        // Uses the same findProjectsByPattern used by directory name inference.
-        // Only runs on the error path, so the extra API cost is acceptable.
-        const similar = await findProjectsByPattern(parsed.projectSlug);
-        const suggestions: string[] = [];
-        if (similar.length > 0) {
-          const names = similar
-            .slice(0, 3)
-            .map((p) => `'${p.orgSlug}/${p.slug}'`);
-          suggestions.push(`Similar projects: ${names.join(", ")}`);
-        }
-        suggestions.push(
-          "No project with this slug found in any accessible organization"
-        );
-        throw new ResolutionError(
-          `Project '${parsed.projectSlug}'`,
-          "not found",
-          "sentry project list",
-          suggestions
-        );
-      }
-
-      const targets: ResolvedTarget[] = matches.map((m) => ({
-        org: m.orgSlug,
-        project: m.slug,
-        projectId: toNumericId(m.id),
-        orgDisplay: m.orgSlug,
-        projectDisplay: m.name,
-      }));
-
-      const uniqueOrgs = [...new Set(targets.map((t) => t.org))];
-      const uniqueProjects = [...new Set(targets.map((t) => t.project))];
-      setOrgProjectContext(uniqueOrgs, uniqueProjects);
-
-      return {
-        targets,
-        footer:
-          matches.length > 1
-            ? `Found '${parsed.projectSlug}' in ${matches.length} organizations`
-            : undefined,
-      };
-    }
-
-    default: {
-      // TypeScript exhaustiveness check - this should never be reached
-      const _exhaustiveCheck: never = parsed;
-      throw new Error(`Unexpected parsed type: ${_exhaustiveCheck}`);
-    }
-  }
-}
-
 /**
  * Fetch issues for a single target project.
  *
@@ -768,65 +574,6 @@ function trimWithProjectGuarantee(
   return issues.filter((_, i) => selected.has(i));
 }
 
-/** Separator for compound cursor entries (pipe — not present in Sentry cursors). */
-const CURSOR_SEP = "|";
-
-/**
- * Encode per-target cursors as a pipe-separated string for storage.
- *
- * The position of each entry matches the **sorted** target order encoded in
- * the context key fingerprint, so we only need to store the cursor values —
- * no org/project metadata is needed in the cursor string itself.
- *
- * Empty string = project exhausted (no more pages).
- *
- * @example "1735689600:0:0||1735689601:0:0" — 3 targets, middle one exhausted
- */
-function encodeCompoundCursor(cursors: (string | null)[]): string {
-  return cursors.map((c) => c ?? "").join(CURSOR_SEP);
-}
-
-/**
- * Decode a compound cursor string back to an array of per-target cursors.
- *
- * Returns `null` for exhausted entries (empty segments) and `string` for active
- * cursors. Returns an empty array if `raw` is empty or looks like a legacy
- * JSON cursor (starts with `[`), causing a fresh start.
- */
-function decodeCompoundCursor(raw: string): (string | null)[] {
-  // Guard against legacy JSON compound cursors or corrupted data
-  if (!raw || raw.startsWith("[")) {
-    return [];
-  }
-  return raw.split(CURSOR_SEP).map((s) => (s === "" ? null : s));
-}
-
-/**
- * Build a compound cursor context key that encodes the full target set, sort,
- * query, and period so that a cursor from one search is never reused for a
- * different search.
- */
-function buildMultiTargetContextKey(
-  targets: ResolvedTarget[],
-  flags: Pick<ListFlags, "sort" | "query" | "period">
-): string {
-  const host = getApiBaseUrl();
-  const targetFingerprint = targets
-    .map((t) => `${t.org}/${t.project}`)
-    .sort()
-    .join(",");
-  const escapedQuery = flags.query
-    ? escapeContextKeyValue(flags.query)
-    : undefined;
-  const escapedPeriod = escapeContextKeyValue(flags.period ?? "90d");
-  const escapedSort = escapeContextKeyValue(flags.sort);
-  return (
-    `host:${host}|type:multi:${targetFingerprint}` +
-    `|sort:${escapedSort}|period:${escapedPeriod}` +
-    (escapedQuery ? `|q:${escapedQuery}` : "")
-  );
-}
-
 /** Build the CLI hint for fetching the next page, preserving active flags. */
 /** Append active non-default issue list flags to a base command string. */
 function appendIssueFlags(base: string, flags: ListFlags): string {
@@ -1140,7 +887,12 @@ async function handleResolvedTargets(
   const { parsed, flags, cwd } = options;
 
   const { targets, footer, skippedSelfHosted, detectedDsns } =
-    await resolveTargetsFromParsedArg(parsed, cwd);
+    await resolveTargetsFromParsedArg(parsed, {
+      cwd,
+      usageHint: USAGE_HINT,
+      enrichProjectIds: true,
+      checkIssueShortId: true,
+    });
 
   if (targets.length === 0) {
     if (skippedSelfHosted) {
@@ -1154,7 +906,11 @@ async function handleResolvedTargets(
 
   // Build a compound cursor context key that encodes the full target set +
   // search parameters so a cursor from one search is never reused for another.
-  const contextKey = buildMultiTargetContextKey(targets, flags);
+  const contextKey = buildMultiTargetContextKey(targets, {
+    sort: flags.sort,
+    query: flags.query,
+    period: flags.period,
+  });
 
   // Resolve per-target start cursors from the stored compound cursor (--cursor resume).
   // Sorted target keys must match the order used in buildMultiTargetContextKey.