feat(release-list): multi-env filtering with smart production default

Environment filtering:
- Support multiple -e flags: -e production -e development
- Support comma-separated: -e production,development
- Variadic flag via Stricli variadic: true

Smart production default:
- When no --environment is passed and a single project is auto-detected,
  call listProjectEnvironments to check if "production" or "prod" exists
- Auto-select it as the default, matching the Sentry web UI behavior
- Show "Environment: production (use -e to change)" hint so it is clear
- One lightweight API call (project environments list), cached by region

API layer:
- Add listProjectEnvironments using @sentry/api listAProject_sEnvironments
- Returns Array<{ id, name, isHidden }> for visible environments

Author: BYK

plugins/sentry-cli/skills/sentry-cli/references/release.md

@@ -18,7 +18,7 @@ List releases with adoption and health metrics
 **Flags:**
 - `-n, --limit <value> - Maximum number of releases to list - (default: "25")`
 - `-s, --sort <value> - Sort: date, sessions, users, crash_free_sessions (cfs), crash_free_users (cfu) - (default: "date")`
-- `-e, --environment <value> - Filter by environment (e.g., production)`
+- `-e, --environment <value>... - Filter by environment (repeatable, comma-separated)`
 - `-t, --period <value> - Health stats period (e.g., 24h, 7d, 14d, 90d) - (default: "90d")`
 - `--status <value> - Filter by status: open (default) or archived - (default: "open")`
 - `-f, --fresh - Bypass cache, re-detect projects, and fetch fresh data`

src/commands/release/list.ts

@@ -9,6 +9,7 @@ import type { OrgReleaseResponse } from "@sentry/api";
 import type { SentryContext } from "../../context.js";
 import {
   type ListReleasesOptions,
+  listProjectEnvironments,
   listReleasesForProject,
   listReleasesPaginated,
   type ReleaseSortValue,
@@ -274,6 +275,65 @@ function formatListHuman(result: ListResult<ReleaseWithOrg>): string {
 // Auto-detect override: resolve DSN → project-scoped listing
 // ---------------------------------------------------------------------------
 
+/** Deduplicate resolved targets by org+project key. */
+function deduplicateTargets(targets: ResolvedTarget[]): ResolvedTarget[] {
+  const seen = new Set<string>();
+  const result: ResolvedTarget[] = [];
+  for (const t of targets) {
+    const key = `${t.org}/${t.project}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(t);
+    }
+  }
+  return result;
+}
+
+/** Resolve a project slug to a numeric ID array for the API query param. */
+async function resolveProjectIds(
+  org: string,
+  project: string
+): Promise<number[] | undefined> {
+  try {
+    const { getProject } = await import("../../lib/api-client.js");
+    const info = await getProject(org, project);
+    const id = toNumericId(info.id);
+    return id ? [id] : undefined;
+  } catch {
+    return;
+  }
+}
+
+/**
+ * Fetch releases for a list of resolved targets, scoped by project ID.
+ *
+ * Each target contributes releases tagged with its org slug. Results are
+ * merged and truncated to `limit`.
+ */
+async function fetchReleasesForTargets(
+  config: OrgListConfig<OrgReleaseResponse, ReleaseWithOrg>,
+  targets: ResolvedTarget[],
+  extra: ExtraApiOptions,
+  limit: number
+): Promise<ReleaseWithOrg[]> {
+  const allItems: ReleaseWithOrg[] = [];
+  for (const t of targets) {
+    const ids = t.projectId
+      ? [t.projectId]
+      : await resolveProjectIds(t.org, t.project);
+    const { data } = await listReleasesPaginated(t.org, {
+      perPage: Math.min(limit, 100),
+      health: true,
+      project: ids,
+      ...extra,
+    });
+    for (const release of data) {
+      allItems.push(config.withOrg(release, t.org));
+    }
+  }
+  return allItems;
+}
+
 /**
  * Custom auto-detect handler that resolves DSN/config to org+project targets,
  * then fetches releases scoped to each detected project.
@@ -283,6 +343,9 @@ function formatListHuman(result: ListResult<ReleaseWithOrg>): string {
  * hundreds of projects, the specific project's releases get buried.
  * This override uses `resolveAllTargets` to get project context from DSN
  * detection, then passes project IDs to the API for scoped results.
+ *
+ * When no `--environment` is given and a single project is detected,
+ * auto-defaults to the `production` or `prod` environment if it exists.
  */
 async function handleAutoDetectWithProject(
   config: OrgListConfig<OrgReleaseResponse, ReleaseWithOrg>,
@@ -293,96 +356,96 @@ async function handleAutoDetectWithProject(
   const resolved = await resolveAllTargets({ cwd });
 
   if (resolved.targets.length === 0) {
-    // No DSN/config found — fall back to org-wide listing via listForOrg
-    const { data } = await listReleasesPaginated("", {
-      perPage: flags.limit,
-      health: true,
-      ...extra,
-    });
     return {
-      items: data.map((r) => config.withOrg(r, "")),
+      items: [],
       hint: "No project detected. Specify a target: sentry release list <org>/<project>",
     };
   }
 
-  // Deduplicate by org+project
-  const seen = new Set<string>();
-  const unique: ResolvedTarget[] = [];
-  for (const t of resolved.targets) {
-    const key = `${t.org}/${t.project}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      unique.push(t);
-    }
-  }
-
-  // Fetch releases scoped to each detected project
-  const allItems: ReleaseWithOrg[] = [];
-  const hintParts: string[] = [];
+  const unique = deduplicateTargets(resolved.targets);
 
-  for (const t of unique) {
-    const projectIds = t.projectId ? [t.projectId] : undefined;
-    // If we don't have a numeric project ID, try to resolve it
-    const ids = projectIds ?? (await resolveProjectIds(t.org, t.project));
-    const { data } = await listReleasesPaginated(t.org, {
-      perPage: Math.min(flags.limit, 100),
-      health: true,
-      project: ids,
-      ...extra,
-    });
-    for (const release of data) {
-      allItems.push(config.withOrg(release, t.org));
-    }
+  // Smart default: auto-select production env when user omitted --environment
+  const effectiveExtra = { ...extra };
+  if (!effectiveExtra.environment && unique.length === 1 && unique[0]) {
+    effectiveExtra.environment = await resolveDefaultEnvironment(
+      unique[0].org,
+      unique[0].project
+    );
   }
 
+  const allItems = await fetchReleasesForTargets(
+    config,
+    unique,
+    effectiveExtra,
+    flags.limit
+  );
   const limited = allItems.slice(0, flags.limit);
 
+  const hintParts: string[] = [];
   if (limited.length === 0) {
     const projects = unique.map((t) => `${t.org}/${t.project}`).join(", ");
     hintParts.push(`No releases found for ${projects}.`);
   }
-
   if (resolved.footer) {
     hintParts.push(resolved.footer);
   }
-
   const detectedFrom = unique
     .filter((t) => t.detectedFrom)
     .map((t) => `${t.project} (from ${t.detectedFrom})`)
     .join(", ");
   if (detectedFrom) {
     hintParts.push(`Detected: ${detectedFrom}`);
   }
-
+  if (effectiveExtra.environment) {
+    hintParts.push(
+      `Environment: ${effectiveExtra.environment.join(", ")} (use -e to change)`
+    );
+  }
   return {
     items: limited,
     hint: hintParts.length > 0 ? hintParts.join("\n") : undefined,
   };
 }
 
-/** Resolve a project slug to a numeric ID array for the API query param. */
-async function resolveProjectIds(
+// ---------------------------------------------------------------------------
+// Flags
+// ---------------------------------------------------------------------------
+
+/** Known production environment names to auto-detect as default. */
+const PRODUCTION_ENV_NAMES = ["production", "prod"];
+
+/**
+ * Resolve environment filter for the API call.
+ *
+ * When the user passes `-e`, those values are used directly.
+ * When no `-e` is given and we have a detected project, check if
+ * `production` or `prod` exists and default to it — matching the
+ * Sentry web UI's default behavior of showing production releases.
+ *
+ * Returns `undefined` (all environments) if no production env is found.
+ */
+async function resolveDefaultEnvironment(
   org: string,
   project: string
-): Promise<number[] | undefined> {
+): Promise<string[] | undefined> {
   try {
-    const { getProject } = await import("../../lib/api-client.js");
-    const info = await getProject(org, project);
-    const id = toNumericId(info.id);
-    return id ? [id] : undefined;
+    const envs = await listProjectEnvironments(org, project);
+    const names = envs.map((e) => e.name);
+    for (const candidate of PRODUCTION_ENV_NAMES) {
+      if (names.includes(candidate)) {
+        return [candidate];
+      }
+    }
   } catch {
-    return;
+    // Environment listing failed — don't filter
   }
+  return;
 }
 
-// ---------------------------------------------------------------------------
-// Flags
-// ---------------------------------------------------------------------------
-
 type ListFlags = {
   readonly limit: number;
   readonly sort: ReleaseSortValue;
-  readonly environment?: string;
+  readonly environment?: readonly string[];
   readonly period: string;
   readonly status: string;
   readonly json: boolean;
@@ -445,7 +508,8 @@ export const listCommand = buildListCommand("release", {
       environment: {
         kind: "parsed" as const,
         parse: String,
-        brief: "Filter by environment (e.g., production)",
+        brief: "Filter by environment (repeatable, comma-separated)",
+        variadic: true as const,
         optional: true as const,
       },
       period: {
@@ -466,9 +530,16 @@ export const listCommand = buildListCommand("release", {
   async *func(this: SentryContext, flags: ListFlags, target?: string) {
     const { cwd } = this;
     const parsed = parseOrgProjectArg(target);
+    // Flatten: -e prod,dev -e staging → ["prod", "dev", "staging"]
+    const envFilter = flags.environment
+      ? [...flags.environment]
+          .flatMap((v) => v.split(","))
+          .map((s) => s.trim())
+          .filter(Boolean)
+      : undefined;
     const extra: ExtraApiOptions = {
       sort: flags.sort,
-      environment: flags.environment ? [flags.environment] : undefined,
+      environment: envFilter,
       statsPeriod: flags.period,
       status: flags.status,
     };

src/lib/api-client.ts

@@ -95,6 +95,7 @@ export {
   deleteRelease,
   getRelease,
   type ListReleasesOptions,
+  listProjectEnvironments,
   listReleaseDeploys,
   listReleasesForProject,
   listReleasesPaginated,

src/lib/api/releases.ts

@@ -11,6 +11,7 @@ import {
   createANewReleaseForAnOrganization,
   deleteAnOrganization_sRelease,
   listAnOrganization_sReleases,
+  listAProject_sEnvironments,
   listARelease_sDeploys,
   retrieveAnOrganization_sRelease,
   updateAnOrganization_sRelease,
@@ -529,3 +530,37 @@ export function setCommitsLocal(
 ): Promise<OrgReleaseResponse> {
   return updateRelease(orgSlug, version, { commits });
 }
+
+// ---------------------------------------------------------------------------
+// Environments
+// ---------------------------------------------------------------------------
+
+/** A visible project environment. */
+export type ProjectEnvironment = {
+  id: string;
+  name: string;
+  isHidden: boolean;
+};
+
+/**
+ * List visible environments for a project.
+ *
+ * Lightweight call — returns a small array of `{ id, name, isHidden }`.
+ * Used to auto-detect a production environment for smart defaults.
+ */
+export async function listProjectEnvironments(
+  orgSlug: string,
+  projectSlug: string
+): Promise<ProjectEnvironment[]> {
+  const config = await getOrgSdkConfig(orgSlug);
+  const result = await listAProject_sEnvironments({
+    ...config,
+    path: {
+      organization_id_or_slug: orgSlug,
+      project_id_or_slug: projectSlug,
+    },
+    query: { visibility: "visible" },
+  });
+  const data = unwrapResult(result, "Failed to list environments");
+  return data as unknown as ProjectEnvironment[];
+}