Merge pull request #14 from betegon/feat/event-command

feat(event): add event get command and refactor target resolution

Author: betegon

packages/cli/src/app.ts

@@ -1,6 +1,7 @@
 import { buildApplication, buildRouteMap } from "@stricli/core";
 import { apiCommand } from "./commands/api.js";
 import { authRoute } from "./commands/auth/index.js";
+import { eventRoute } from "./commands/event/index.js";
 import { issueRoute } from "./commands/issue/index.js";
 import { orgRoute } from "./commands/org/index.js";
 import { projectRoute } from "./commands/project/index.js";
@@ -11,6 +12,7 @@ const routes = buildRouteMap({
     org: orgRoute,
     project: projectRoute,
     issue: issueRoute,
+    event: eventRoute,
     api: apiCommand,
   },
   docs: {

packages/cli/src/commands/event/get.ts

@@ -0,0 +1,117 @@
+/**
+ * sentry event get
+ *
+ * Get detailed information about a Sentry event.
+ */
+
+import { buildCommand } from "@stricli/core";
+import type { SentryContext } from "../../context.js";
+import { getEvent } from "../../lib/api-client.js";
+import { formatEventDetails } from "../../lib/formatters/human.js";
+import { writeJson } from "../../lib/formatters/json.js";
+import { resolveOrgAndProject } from "../../lib/resolve-target.js";
+import type { SentryEvent } from "../../types/index.js";
+
+type GetFlags = {
+  readonly org?: string;
+  readonly project?: string;
+  readonly json: boolean;
+};
+
+/**
+ * Write human-readable event output to stdout.
+ *
+ * @param stdout - Output stream
+ * @param event - The event to display
+ * @param detectedFrom - Optional source description for auto-detection
+ */
+function writeHumanOutput(
+  stdout: NodeJS.WriteStream,
+  event: SentryEvent,
+  detectedFrom?: string
+): void {
+  const lines = formatEventDetails(event, `Event ${event.eventID}`);
+
+  // Skip leading empty line for standalone display
+  const output = lines.slice(1);
+  stdout.write(`${output.join("\n")}\n`);
+
+  if (detectedFrom) {
+    stdout.write(`\nDetected from ${detectedFrom}\n`);
+  }
+}
+
+export const getCommand = buildCommand({
+  docs: {
+    brief: "Get details of a specific event",
+    fullDescription:
+      "Retrieve detailed information about a Sentry event by its ID.\n\n" +
+      "The organization and project are resolved from:\n" +
+      "  1. --org and --project flags\n" +
+      "  2. Config defaults\n" +
+      "  3. SENTRY_DSN environment variable or source code detection",
+  },
+  parameters: {
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief:
+            "Event ID (hexadecimal, e.g., 9999aaaaca8b46d797c23c6077c6ff01)",
+          parse: String,
+        },
+      ],
+    },
+    flags: {
+      org: {
+        kind: "parsed",
+        parse: String,
+        brief: "Organization slug",
+        optional: true,
+      },
+      project: {
+        kind: "parsed",
+        parse: String,
+        brief: "Project slug",
+        optional: true,
+      },
+      json: {
+        kind: "boolean",
+        brief: "Output as JSON",
+        default: false,
+      },
+    },
+  },
+  async func(
+    this: SentryContext,
+    flags: GetFlags,
+    eventId: string
+  ): Promise<void> {
+    const { process, cwd } = this;
+    const { stdout } = process;
+
+    const target = await resolveOrgAndProject({
+      org: flags.org,
+      project: flags.project,
+      cwd,
+    });
+
+    if (!target) {
+      throw new Error(
+        "Organization and project are required to fetch an event.\n\n" +
+          "Please specify them using:\n" +
+          `  sentry event get ${eventId} --org <org-slug> --project <project-slug>\n\n` +
+          "Or set SENTRY_DSN environment variable for automatic detection."
+      );
+    }
+
+    const event = await getEvent(target.org, target.project, eventId);
+
+    if (flags.json) {
+      writeJson(stdout, event);
+      return;
+    }
+
+    writeHumanOutput(stdout, event, target.detectedFrom);
+  },
+});

packages/cli/src/commands/event/index.ts

@@ -0,0 +1,15 @@
+import { buildRouteMap } from "@stricli/core";
+import { getCommand } from "./get.js";
+
+export const eventRoute = buildRouteMap({
+  routes: {
+    get: getCommand,
+  },
+  docs: {
+    brief: "View Sentry events",
+    fullDescription:
+      "View detailed event data from Sentry. " +
+      "Use 'sentry event get <event-id>' to view a specific event.",
+    hideRoute: {},
+  },
+});

packages/cli/src/commands/issue/get.ts

@@ -12,72 +12,33 @@ import {
   getLatestEvent,
   isShortId,
 } from "../../lib/api-client.js";
-import { getCachedProject, getDefaultOrganization } from "../../lib/config.js";
-import { detectDsn } from "../../lib/dsn/index.js";
 import {
   formatEventDetails,
   formatIssueDetails,
 } from "../../lib/formatters/human.js";
 import { writeJson } from "../../lib/formatters/json.js";
+import { resolveOrg } from "../../lib/resolve-target.js";
 import type { SentryEvent, SentryIssue } from "../../types/index.js";
 
 type GetFlags = {
   readonly org?: string;
   readonly json: boolean;
-  readonly event: boolean;
 };
 
 /**
- * Try to fetch the latest event for an issue
+ * Try to fetch the latest event for an issue.
+ * Returns undefined if the fetch fails (non-blocking).
  */
 async function tryGetLatestEvent(
   issueId: string
 ): Promise<SentryEvent | undefined> {
   try {
     return await getLatestEvent(issueId);
   } catch {
-    // Event fetch might fail, continue without it
     return;
   }
 }
 
-/**
- * Resolve organization from various sources for short ID lookup
- */
-async function resolveOrg(
-  flagOrg: string | undefined,
-  cwd: string
-): Promise<string | null> {
-  // 1. Check CLI flag
-  if (flagOrg) {
-    return flagOrg;
-  }
-
-  // 2. Check config defaults
-  const defaultOrg = await getDefaultOrganization();
-  if (defaultOrg) {
-    return defaultOrg;
-  }
-
-  // 3. Try DSN auto-detection
-  try {
-    const dsn = await detectDsn(cwd);
-    if (dsn?.orgId) {
-      // Check cache for org slug
-      const cached = await getCachedProject(dsn.orgId, dsn.projectId);
-      if (cached) {
-        return cached.orgSlug;
-      }
-      // Fall back to numeric org ID (API accepts both)
-      return dsn.orgId;
-    }
-  } catch {
-    // Detection failed
-  }
-
-  return null;
-}
-
 /**
  * Write human-readable issue output
  */
@@ -100,7 +61,7 @@ export const getCommand = buildCommand({
     brief: "Get details of a specific issue",
     fullDescription:
       "Retrieve detailed information about a Sentry issue by its ID or short ID. " +
-      "Use --event to also fetch the latest event details.\n\n" +
+      "The latest event is automatically included for full context.\n\n" +
       "For short IDs (e.g., SPOTLIGHT-ELECTRON-4D), the organization is resolved from:\n" +
       "  1. --org flag\n" +
       "  2. Config defaults\n" +
@@ -129,11 +90,6 @@ export const getCommand = buildCommand({
         brief: "Output as JSON",
         default: false,
       },
-      event: {
-        kind: "boolean",
-        brief: "Also fetch the latest event",
-        default: false,
-      },
     },
   },
   async func(
@@ -149,22 +105,23 @@ export const getCommand = buildCommand({
     // Check if it's a short ID (contains letters) vs numeric ID
     if (isShortId(issueId)) {
       // Short ID requires organization context
-      const org = await resolveOrg(flags.org, cwd);
-      if (!org) {
+      const resolved = await resolveOrg({ org: flags.org, cwd });
+      if (!resolved) {
         throw new Error(
           "Organization is required for short ID lookup.\n\n" +
             "Please specify it using:\n" +
             `  sentry issue get ${issueId} --org <org-slug>\n\n` +
             "Or set SENTRY_DSN environment variable for automatic detection."
         );
       }
-      issue = await getIssueByShortId(org, issueId);
+      issue = await getIssueByShortId(resolved.org, issueId);
     } else {
       // Numeric ID can be fetched directly
       issue = await getIssue(issueId);
     }
 
-    const event = flags.event ? await tryGetLatestEvent(issue.id) : undefined;
+    // Always fetch the latest event for full context
+    const event = await tryGetLatestEvent(issue.id);
 
     if (flags.json) {
       const output = event ? { issue, event } : { issue };