fastlane-plugin-sentry_api 0.1.0

data/lib/fastlane/plugin/sentry_api/actions/sentry_crash_free_sessions_action.rb

@@ -0,0 +1,283 @@
+require 'fastlane/action'
+require_relative '../helper/sentry_api_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SENTRY_CRASH_FREE_SESSION_RATE = :SENTRY_CRASH_FREE_SESSION_RATE
+      SENTRY_CRASH_FREE_USER_RATE = :SENTRY_CRASH_FREE_USER_RATE
+      SENTRY_TOTAL_SESSIONS = :SENTRY_TOTAL_SESSIONS
+      SENTRY_TOTAL_USERS = :SENTRY_TOTAL_USERS
+      SENTRY_SESSION_GROUPS = :SENTRY_SESSION_GROUPS
+      SENTRY_CRASH_FREE_SESSIONS_STATUS_CODE = :SENTRY_CRASH_FREE_SESSIONS_STATUS_CODE
+      SENTRY_CRASH_FREE_SESSIONS_JSON = :SENTRY_CRASH_FREE_SESSIONS_JSON
+    end
+
+    # Query crash-free session and user rates from the Sentry Sessions API.
+    # Supports aggregate metrics (for week-over-week) and grouped-by-release (for release-over-release).
+    class SentryCrashFreeSessionsAction < Action
+      class << self
+        def run(params)
+          auth_token = params[:auth_token]
+          org_slug = params[:org_slug]
+          project_id = params[:project_id]
+
+          query_params = build_query_params(params, project_id)
+
+          UI.message("Fetching crash-free session metrics from Sentry (#{query_params[:statsPeriod] || 'custom range'})...")
+
+          response = Helper::SentryApiHelper.get_sessions(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            params: query_params
+          )
+
+          status_code = response[:status]
+          json = response[:json]
+
+          unless status_code.between?(200, 299)
+            UI.user_error!("Sentry Sessions API error #{status_code}: #{response[:body]}")
+            return nil
+          end
+
+          result = parse_response(json, params[:group_by])
+
+          # Store in lane context
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_SESSIONS_STATUS_CODE] = status_code
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_SESSIONS_JSON] = json
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_SESSION_RATE] = result[:crash_free_session_rate]
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_USER_RATE] = result[:crash_free_user_rate]
+          Actions.lane_context[SharedValues::SENTRY_TOTAL_SESSIONS] = result[:total_sessions]
+          Actions.lane_context[SharedValues::SENTRY_TOTAL_USERS] = result[:total_users]
+          Actions.lane_context[SharedValues::SENTRY_SESSION_GROUPS] = result[:groups]
+
+          # Log results
+          if result[:groups] && !result[:groups].empty?
+            UI.success("Fetched #{result[:groups].length} session groups")
+            result[:groups].each do |group|
+              label = group[:by].values.first || "aggregate"
+              UI.message("  #{label}: sessions=#{format_pct(group[:crash_free_session_rate])} users=#{format_pct(group[:crash_free_user_rate])}")
+            end
+          else
+            UI.success("Crash-free sessions: #{format_pct(result[:crash_free_session_rate])}")
+            UI.success("Crash-free users: #{format_pct(result[:crash_free_user_rate])}")
+            UI.success("Total sessions: #{result[:total_sessions]}, Total users: #{result[:total_users]}")
+          end
+
+          result
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Query crash-free session and user rates from the Sentry Sessions API"
+        end
+
+        def details
+          [
+            "Queries the Sentry Sessions API for crash-free session rates, crash-free user rates,",
+            "total sessions, and total users. Supports aggregate metrics for a time period",
+            "(useful for week-over-week comparison) and grouped-by-release metrics",
+            "(useful for release-over-release comparison).",
+            "",
+            "Use `stats_period` for rolling windows (e.g. '7d', '14d', '30d'),",
+            "or `start_date` + `end_date` for a specific date range.",
+            "",
+            "API Documentation: https://docs.sentry.io/api/releases/retrieve-release-health-session-statistics/"
+          ].join("\n")
+        end
+
+        def available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :auth_token,
+                                     env_name: "SENTRY_AUTH_TOKEN",
+                                  description: "Sentry API Bearer auth token",
+                                     optional: false,
+                                         type: String,
+                                    sensitive: true,
+                           code_gen_sensitive: true,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :org_slug,
+                                     env_name: "SENTRY_ORG_SLUG",
+                                  description: "Sentry organization slug",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :project_id,
+                                     env_name: "SENTRY_PROJECT_ID",
+                                  description: "Sentry numeric project ID",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry project ID given, pass using `project_id: '12345'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :environment,
+                                     env_name: "SENTRY_ENVIRONMENT",
+                                  description: "Environment filter (e.g. 'production')",
+                                     optional: true,
+                                default_value: "production",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :stats_period,
+                                  description: "Rolling time window (e.g. '7d', '14d', '30d'). Mutually exclusive with start_date/end_date",
+                                     optional: true,
+                                default_value: "7d",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :start_date,
+                                  description: "Start date in ISO 8601 format (e.g. '2026-03-01T00:00:00Z'). Use with end_date instead of stats_period",
+                                     optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :end_date,
+                                  description: "End date in ISO 8601 format (e.g. '2026-03-08T00:00:00Z'). Use with start_date instead of stats_period",
+                                     optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :group_by,
+                                  description: "Group results by dimension: 'release', 'environment', or nil for aggregate",
+                                     optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :per_page,
+                                  description: "Number of groups to return when group_by is set (max 100)",
+                                     optional: true,
+                                default_value: 10,
+                                         type: Integer),
+            FastlaneCore::ConfigItem.new(key: :order_by,
+                                  description: "Sort order for grouped results (e.g. '-sum(session)', '-crash_free_rate(session)')",
+                                     optional: true,
+                                default_value: "-sum(session)",
+                                         type: String)
+          ]
+        end
+
+        def output
+          [
+            ['SENTRY_CRASH_FREE_SESSION_RATE', 'Crash-free session rate as a float (e.g. 0.9974)'],
+            ['SENTRY_CRASH_FREE_USER_RATE', 'Crash-free user rate as a float (e.g. 0.9981)'],
+            ['SENTRY_TOTAL_SESSIONS', 'Total number of sessions in the period'],
+            ['SENTRY_TOTAL_USERS', 'Total number of unique users in the period'],
+            ['SENTRY_SESSION_GROUPS', 'Array of group hashes when group_by is set'],
+            ['SENTRY_CRASH_FREE_SESSIONS_STATUS_CODE', 'HTTP status code from the Sentry API'],
+            ['SENTRY_CRASH_FREE_SESSIONS_JSON', 'Raw JSON response from the Sentry API']
+          ]
+        end
+
+        def return_value
+          "A hash with :crash_free_session_rate, :crash_free_user_rate, :total_sessions, :total_users, and :groups (when group_by is set)."
+        end
+
+        def authors
+          ["crazymanish"]
+        end
+
+        def example_code
+          [
+            '# Aggregate crash-free rate for last 7 days
+            sentry_crash_free_sessions(stats_period: "7d")
+            rate = lane_context[SharedValues::SENTRY_CRASH_FREE_SESSION_RATE]
+            UI.message("Crash-free sessions: #{(rate * 100).round(2)}%")',
+
+            '# Grouped by release (release-over-release comparison)
+            result = sentry_crash_free_sessions(stats_period: "30d", group_by: "release", per_page: 5)
+            result[:groups].each do |g|
+              puts "#{g[:by]["release"]}: #{(g[:crash_free_session_rate] * 100).round(2)}%"
+            end',
+
+            '# Custom date range (previous week for week-over-week)
+            sentry_crash_free_sessions(start_date: "2026-02-24T00:00:00Z", end_date: "2026-03-03T00:00:00Z")'
+          ]
+        end
+
+        def category
+          :misc
+        end
+
+        def is_supported?(platform)
+          true
+        end
+
+        private
+
+        def build_query_params(params, project_id)
+          fields = [
+            'crash_free_rate(session)',
+            'crash_free_rate(user)',
+            'sum(session)',
+            'count_unique(user)'
+          ]
+
+          query_params = {
+            field: fields,
+            project: project_id.to_s,
+            includeSeries: '0'
+          }
+
+          # Time range: stats_period OR start/end
+          if params[:start_date] && params[:end_date]
+            query_params[:start] = params[:start_date]
+            query_params[:end] = params[:end_date]
+          else
+            query_params[:statsPeriod] = params[:stats_period] || '7d'
+          end
+
+          query_params[:environment] = params[:environment] if params[:environment]
+
+          # Grouping
+          if params[:group_by]
+            query_params[:groupBy] = params[:group_by]
+            query_params[:per_page] = params[:per_page].to_s if params[:per_page]
+            query_params[:orderBy] = params[:order_by] if params[:order_by]
+          end
+
+          query_params
+        end
+
+        def parse_response(json, group_by)
+          groups_data = json&.dig('groups') || []
+
+          if group_by && !group_by.empty?
+            # Grouped response: return array of group results
+            groups = groups_data.map do |group|
+              totals = group['totals'] || {}
+              {
+                by: group['by'] || {},
+                crash_free_session_rate: totals['crash_free_rate(session)'],
+                crash_free_user_rate: totals['crash_free_rate(user)'],
+                total_sessions: totals['sum(session)'],
+                total_users: totals['count_unique(user)']
+              }
+            end
+
+            {
+              crash_free_session_rate: nil,
+              crash_free_user_rate: nil,
+              total_sessions: nil,
+              total_users: nil,
+              groups: groups
+            }
+          else
+            # Aggregate response: single group
+            totals = groups_data.dig(0, 'totals') || {}
+
+            {
+              crash_free_session_rate: totals['crash_free_rate(session)'],
+              crash_free_user_rate: totals['crash_free_rate(user)'],
+              total_sessions: totals['sum(session)'],
+              total_users: totals['count_unique(user)'],
+              groups: nil
+            }
+          end
+        end
+
+        def format_pct(value)
+          return "N/A" if value.nil?
+
+          "#{(value * 100).round(4)}%"
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sentry_api/actions/sentry_crash_free_users_action.rb

@@ -0,0 +1,198 @@
+require 'fastlane/action'
+require_relative '../helper/sentry_api_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SENTRY_CRASH_FREE_USER_RATE_ONLY = :SENTRY_CRASH_FREE_USER_RATE_ONLY
+      SENTRY_TOTAL_USERS_ONLY = :SENTRY_TOTAL_USERS_ONLY
+      SENTRY_CRASH_FREE_USERS_STATUS_CODE = :SENTRY_CRASH_FREE_USERS_STATUS_CODE
+      SENTRY_CRASH_FREE_USERS_JSON = :SENTRY_CRASH_FREE_USERS_JSON
+    end
+
+    # Convenience action focused on user-centric crash-free metrics.
+    # Queries the same Sentry Sessions API but returns user-focused results.
+    class SentryCrashFreeUsersAction < Action
+      class << self
+        def run(params)
+          auth_token = params[:auth_token]
+          org_slug = params[:org_slug]
+          project_id = params[:project_id]
+
+          query_params = build_query_params(params, project_id)
+
+          UI.message("Fetching crash-free user metrics from Sentry (#{query_params[:statsPeriod] || 'custom range'})...")
+
+          response = Helper::SentryApiHelper.get_sessions(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            params: query_params
+          )
+
+          status_code = response[:status]
+          json = response[:json]
+
+          unless status_code.between?(200, 299)
+            UI.user_error!("Sentry Sessions API error #{status_code}: #{response[:body]}")
+            return nil
+          end
+
+          result = parse_response(json)
+
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_USERS_STATUS_CODE] = status_code
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_USERS_JSON] = json
+          Actions.lane_context[SharedValues::SENTRY_CRASH_FREE_USER_RATE_ONLY] = result[:crash_free_user_rate]
+          Actions.lane_context[SharedValues::SENTRY_TOTAL_USERS_ONLY] = result[:total_users]
+
+          UI.success("Crash-free users: #{format_pct(result[:crash_free_user_rate])}")
+          UI.success("Total unique users: #{result[:total_users]}")
+
+          result
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Query crash-free user rate from the Sentry Sessions API"
+        end
+
+        def details
+          [
+            "Convenience action for fetching user-centric crash-free metrics from Sentry.",
+            "Queries the Sessions API for crash_free_rate(user) and count_unique(user).",
+            "For full session + user metrics, use sentry_crash_free_sessions instead.",
+            "",
+            "API Documentation: https://docs.sentry.io/api/releases/retrieve-release-health-session-statistics/"
+          ].join("\n")
+        end
+
+        def available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :auth_token,
+                                     env_name: "SENTRY_AUTH_TOKEN",
+                                  description: "Sentry API Bearer auth token",
+                                     optional: false,
+                                         type: String,
+                                    sensitive: true,
+                           code_gen_sensitive: true,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :org_slug,
+                                     env_name: "SENTRY_ORG_SLUG",
+                                  description: "Sentry organization slug",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :project_id,
+                                     env_name: "SENTRY_PROJECT_ID",
+                                  description: "Sentry numeric project ID",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry project ID given, pass using `project_id: '12345'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :environment,
+                                     env_name: "SENTRY_ENVIRONMENT",
+                                  description: "Environment filter (e.g. 'production')",
+                                     optional: true,
+                                default_value: "production",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :stats_period,
+                                  description: "Rolling time window (e.g. '7d', '14d', '30d')",
+                                     optional: true,
+                                default_value: "7d",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :start_date,
+                                  description: "Start date in ISO 8601 format. Use with end_date instead of stats_period",
+                                     optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :end_date,
+                                  description: "End date in ISO 8601 format. Use with start_date instead of stats_period",
+                                     optional: true,
+                                         type: String)
+          ]
+        end
+
+        def output
+          [
+            ['SENTRY_CRASH_FREE_USER_RATE_ONLY', 'Crash-free user rate as a float (e.g. 0.9991)'],
+            ['SENTRY_TOTAL_USERS_ONLY', 'Total unique users in the period'],
+            ['SENTRY_CRASH_FREE_USERS_STATUS_CODE', 'HTTP status code from the Sentry API'],
+            ['SENTRY_CRASH_FREE_USERS_JSON', 'Raw JSON response from the Sentry API']
+          ]
+        end
+
+        def return_value
+          "A hash with :crash_free_user_rate and :total_users."
+        end
+
+        def authors
+          ["crazymanish"]
+        end
+
+        def example_code
+          [
+            'sentry_crash_free_users(stats_period: "7d")
+            rate = lane_context[SharedValues::SENTRY_CRASH_FREE_USER_RATE_ONLY]
+            UI.message("Crash-free users: #{(rate * 100).round(2)}%")'
+          ]
+        end
+
+        def category
+          :misc
+        end
+
+        def is_supported?(platform)
+          true
+        end
+
+        private
+
+        def build_query_params(params, project_id)
+          fields = [
+            'crash_free_rate(user)',
+            'count_unique(user)'
+          ]
+
+          query_params = {
+            field: fields,
+            project: project_id.to_s,
+            includeSeries: '0'
+          }
+
+          if params[:start_date] && params[:end_date]
+            query_params[:start] = params[:start_date]
+            query_params[:end] = params[:end_date]
+          else
+            query_params[:statsPeriod] = params[:stats_period] || '7d'
+          end
+
+          query_params[:environment] = params[:environment] if params[:environment]
+
+          query_params
+        end
+
+        def parse_response(json)
+          groups_data = json&.dig('groups') || []
+          totals = groups_data.dig(0, 'totals') || {}
+
+          {
+            crash_free_user_rate: totals['crash_free_rate(user)'],
+            total_users: totals['count_unique(user)']
+          }
+        end
+
+        def format_pct(value)
+          return "N/A" if value.nil?
+
+          "#{(value * 100).round(4)}%"
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sentry_api/actions/sentry_list_issues_action.rb

@@ -0,0 +1,207 @@
+require 'fastlane/action'
+require_relative '../helper/sentry_api_helper'
+
+module Fastlane
+  module Actions
+    module SharedValues
+      SENTRY_ISSUES = :SENTRY_ISSUES
+      SENTRY_ISSUE_COUNT = :SENTRY_ISSUE_COUNT
+      SENTRY_ISSUES_STATUS_CODE = :SENTRY_ISSUES_STATUS_CODE
+      SENTRY_ISSUES_JSON = :SENTRY_ISSUES_JSON
+    end
+
+    # Fetch issues from a Sentry project. Supports filtering by release, query, sort order, etc.
+    # Uses the Projects Issues API: GET /api/0/projects/{org}/{project}/issues/
+    class SentryListIssuesAction < Action
+      class << self
+        def run(params)
+          auth_token = params[:auth_token]
+          org_slug = params[:org_slug]
+          project_slug = params[:project_slug]
+
+          query_params = build_query_params(params)
+
+          UI.message("Fetching issues from Sentry project '#{project_slug}'...")
+
+          response = Helper::SentryApiHelper.get_issues(
+            auth_token: auth_token,
+            org_slug: org_slug,
+            project_slug: project_slug,
+            params: query_params
+          )
+
+          status_code = response[:status]
+          json = response[:json]
+
+          unless status_code.between?(200, 299)
+            UI.user_error!("Sentry Issues API error #{status_code}: #{response[:body]}")
+            return nil
+          end
+
+          issues = parse_response(json)
+          issue_count = issues.length
+
+          Actions.lane_context[SharedValues::SENTRY_ISSUES_STATUS_CODE] = status_code
+          Actions.lane_context[SharedValues::SENTRY_ISSUES_JSON] = json
+          Actions.lane_context[SharedValues::SENTRY_ISSUES] = issues
+          Actions.lane_context[SharedValues::SENTRY_ISSUE_COUNT] = issue_count
+
+          UI.success("Fetched #{issue_count} issues from '#{project_slug}'")
+          issues.first(5).each do |issue|
+            UI.message("  #{issue[:short_id]}: #{issue[:title]} (#{issue[:event_count]} events, #{issue[:user_count]} users)")
+          end
+
+          { issues: issues, count: issue_count }
+        end
+
+        #####################################################
+        # @!group Documentation
+        #####################################################
+
+        def description
+          "Fetch issues from a Sentry project"
+        end
+
+        def details
+          [
+            "Fetches issues from a Sentry project using the Projects Issues API.",
+            "Supports filtering by release version, query string, sort order, and pagination.",
+            "Useful for comparing issues across releases (e.g. latest vs previous).",
+            "",
+            "API Documentation: https://docs.sentry.io/api/events/list-a-projects-issues/"
+          ].join("\n")
+        end
+
+        def available_options
+          [
+            FastlaneCore::ConfigItem.new(key: :auth_token,
+                                     env_name: "SENTRY_AUTH_TOKEN",
+                                  description: "Sentry API Bearer auth token",
+                                     optional: false,
+                                         type: String,
+                                    sensitive: true,
+                           code_gen_sensitive: true,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry auth token given, pass using `auth_token: 'token'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :org_slug,
+                                     env_name: "SENTRY_ORG_SLUG",
+                                  description: "Sentry organization slug",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry org slug given, pass using `org_slug: 'my-org'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :project_slug,
+                                     env_name: "SENTRY_PROJECT_SLUG",
+                                  description: "Sentry project slug (e.g. 'ios', 'android')",
+                                     optional: false,
+                                         type: String,
+                                verify_block: proc do |value|
+                                                UI.user_error!("No Sentry project slug given, pass using `project_slug: 'ios'`") if value.to_s.empty?
+                                              end),
+            FastlaneCore::ConfigItem.new(key: :query,
+                                  description: "Sentry search query (e.g. 'is:unresolved', 'is:unresolved release:v1.0')",
+                                     optional: true,
+                                default_value: "is:unresolved",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :sort,
+                                  description: "Sort order: 'date', 'new', 'freq', 'priority', 'user', 'trend'",
+                                     optional: true,
+                                default_value: "freq",
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :stats_period,
+                                  description: "Time window for issue stats (e.g. '7d', '14d', '30d')",
+                                     optional: true,
+                                         type: String),
+            FastlaneCore::ConfigItem.new(key: :per_page,
+                                  description: "Number of issues to return (max 100)",
+                                     optional: true,
+                                default_value: 25,
+                                         type: Integer),
+            FastlaneCore::ConfigItem.new(key: :cursor,
+                                  description: "Pagination cursor for fetching next page of results",
+                                     optional: true,
+                                         type: String)
+          ]
+        end
+
+        def output
+          [
+            ['SENTRY_ISSUES', 'Array of issue hashes with :id, :short_id, :title, :event_count, :user_count, :first_seen, :last_seen, :level, :status'],
+            ['SENTRY_ISSUE_COUNT', 'Number of issues returned'],
+            ['SENTRY_ISSUES_STATUS_CODE', 'HTTP status code from the Sentry API'],
+            ['SENTRY_ISSUES_JSON', 'Raw JSON response from the Sentry API']
+          ]
+        end
+
+        def return_value
+          "A hash with :issues (array of issue hashes) and :count (number of issues)."
+        end
+
+        def authors
+          ["crazymanish"]
+        end
+
+        def example_code
+          [
+            '# Fetch unresolved issues sorted by frequency
+            result = sentry_list_issues(query: "is:unresolved", sort: "freq", per_page: 10)
+            result[:issues].each do |issue|
+              UI.message("##{issue[:short_id]}: #{issue[:title]} (#{issue[:event_count]} events)")
+            end',
+
+            '# Fetch issues for a specific release
+            sentry_list_issues(query: "is:unresolved release:v25.10.0", sort: "freq")',
+
+            '# Fetch new issues in the latest release
+            sentry_list_issues(query: "is:unresolved first-release:v25.10.0", sort: "date")'
+          ]
+        end
+
+        def category
+          :misc
+        end
+
+        def is_supported?(platform)
+          true
+        end
+
+        private
+
+        def build_query_params(params)
+          query_params = {}
+
+          query_params[:query] = params[:query] if params[:query]
+          query_params[:sort] = params[:sort] if params[:sort]
+          query_params[:statsPeriod] = params[:stats_period] if params[:stats_period]
+          query_params[:per_page] = params[:per_page].to_s if params[:per_page]
+          query_params[:cursor] = params[:cursor] if params[:cursor]
+
+          query_params
+        end
+
+        def parse_response(json)
+          return [] unless json.is_a?(Array)
+
+          json.map do |issue|
+            {
+              id: issue['id'],
+              short_id: issue['shortId'],
+              title: issue['title'],
+              culprit: issue['culprit'],
+              level: issue['level'],
+              status: issue['status'],
+              event_count: (issue['count'] || '0').to_i,
+              user_count: issue['userCount'] || 0,
+              first_seen: issue['firstSeen'],
+              last_seen: issue['lastSeen'],
+              permalink: issue['permalink'],
+              metadata: issue['metadata']
+            }
+          end
+        end
+      end
+    end
+  end
+end