activerabbit-cli 1.0.0

data/lib/activerabbit/formatters.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module ActiveRabbit
+  module Formatters
+    def self.format(payload, format)
+      case format.to_s.downcase
+      when "json" then Json.format(payload)
+      when "md", "markdown" then Markdown.format(payload)
+      else Human.format(payload)
+      end
+    end
+
+    module Json
+      def self.format(payload)
+        out = {
+          "project" => payload["project"],
+          "generated_at" => payload["generated_at"],
+          "command" => payload["command"],
+          "data" => payload["data"]
+        }
+        JSON.pretty_generate(out)
+      end
+    end
+
+    module Markdown
+      def self.format(payload)
+        cmd = payload["command"]
+        data = payload["data"] || {}
+        case cmd
+        when "apps" then apps_md(data)
+        when "status" then status_md(data)
+        when "incidents" then incidents_md(data)
+        when "incident_detail" then incident_detail_md(data)
+        when "explain" then explain_md(data)
+        when "trace" then trace_md(data)
+        when "deploy_check" then deploy_check_md(data)
+        when "doctor" then doctor_md(data)
+        else generic_md(payload)
+        end
+      end
+
+      def self.apps_md(data)
+        list = data["apps"] || []
+        rows = list.map { |a| "| #{a["slug"]} | #{a["name"]} | #{a["environment"]} | #{a["error_count_24h"]} |" }
+        <<~MD
+          ## Apps
+          | Slug | Name | Env | Errors (24h) |
+          |------|------|-----|-------------:|
+          #{rows.join("\n")}
+        MD
+      end
+
+      def self.status_md(data)
+        top = data["top_issue"]
+        <<~MD
+          ## #{data["name"]} (#{data["app"]})
+          **Health:** #{data["health"]} · **Errors (24h):** #{data["error_count_24h"]} · **p95:** #{data["p95_latency_ms"]} ms
+          **Deploy:** #{data["deploy_status"]} · Last: #{data["last_deploy_at"]}
+
+          #{top ? "**Top issue:** #{top["title"]} (#{top["count"]} events, #{top["severity"]})" : ""}
+        MD
+      end
+
+      def self.incidents_md(data)
+        list = data["incidents"] || []
+        rows = list.map { |i| "| #{i["id"]} | #{i["severity"]} | #{i["title"]} | #{i["endpoint"]} | #{i["count"]} | #{i["last_seen_at"]} |" }
+        <<~MD
+          ## Incidents
+          | ID | Severity | Title | Endpoint | Count | Last seen |
+          |---|---:|---|---|---:|---|
+          #{rows.join("\n")}
+        MD
+      end
+
+      def self.incident_detail_md(data)
+        <<~MD
+          ## #{data["exception_class"]}: #{data["message"]}
+          **ID:** #{data["id"]} · **Severity:** #{data["severity"]} · **Status:** #{data["status"]}
+          **Endpoint:** #{data["endpoint"]} · **Count:** #{data["count"]} · **Affected users:** #{data["affected_users"]}
+
+          ### Stack trace
+          ```
+          #{Array(data["backtrace"]).join("\n")}
+          ```
+
+          First seen: #{data["first_seen_at"]} · Last seen: #{data["last_seen_at"]}
+        MD
+      end
+
+      def self.explain_md(data)
+        <<~MD
+          ## #{data["title"]} (#{data["incident_id"]})
+          **Severity:** #{data["severity"]} · **Confidence:** #{(data["confidence_score"] * 100).to_i}%
+
+          ### Root cause
+          #{data["root_cause"]}
+
+          ### Suggested fix
+          #{data["suggested_fix"]}
+
+          ### Affected endpoints
+          #{Array(data["affected_endpoints"]).join(", ")}
+
+          **Regression risk:** #{data["regression_risk"]} · **Tests to run:** #{Array(data["tests_to_run"]).join(", ")}
+        MD
+      end
+
+      def self.trace_md(data)
+        spans = (data["spans"] || []).map { |s| "- #{s["name"]}: #{s["duration_ms"]} ms (#{s["percent"]}%)" }
+        bottlenecks = Array(data["bottlenecks"]).map { |b| "- #{b}" }
+        <<~MD
+          ## Trace: #{data["endpoint"]} (#{data["trace_id"]})
+          **Duration:** #{data["duration_ms"]} ms
+
+          ### Spans
+          #{spans.join("\n")}
+
+          ### Bottlenecks
+          #{bottlenecks.join("\n")}
+        MD
+      end
+
+      def self.deploy_check_md(data)
+        warnings = Array(data["warnings"]).map { |w| "- #{w}" }
+        <<~MD
+          ## Deploy check
+          **Ready:** #{data["ready"]} · **Last deploy:** #{data["last_deploy_at"]}
+          **New errors since deploy:** #{data["new_errors_since_deploy"]}
+          #{warnings.any? ? "**Warnings:**\n#{warnings.join("\n")}" : ""}
+        MD
+      end
+
+      def self.doctor_md(data)
+        <<~MD
+          ## Doctor
+          **Config:** #{data["config_ok"]} · **API:** #{data["api_ok"]} · **App:** #{data["app_ok"]}
+          #{data["message"]}
+        MD
+      end
+
+      def self.generic_md(payload)
+        "## #{payload["command"]}\n\n```json\n#{JSON.pretty_generate(payload["data"])}\n```"
+      end
+    end
+
+    module Human
+      def self.format(payload)
+        cmd = payload["command"]
+        data = payload["data"] || {}
+        case cmd
+        when "apps" then apps_human(data)
+        when "status" then status_human(data)
+        when "incidents" then incidents_human(data)
+        when "incident_detail" then incident_detail_human(data)
+        when "explain" then explain_human(data)
+        when "trace" then trace_human(data)
+        when "deploy_check" then deploy_check_human(data)
+        when "doctor" then doctor_human(data)
+        when "login" then "Logged in. Config saved to #{payload["config_path"]}"
+        else JSON.pretty_generate(data)
+        end
+      end
+
+      def self.apps_human(data)
+        list = data["apps"] || []
+        return "No apps found." if list.empty?
+
+        lines = [UI.c("Apps:", :bold), ""]
+        list.each do |app|
+          env_badge = app["environment"] == "production" ? UI.c("prod", :green) : UI.c(app["environment"], :gray)
+          errors = app["error_count_24h"].to_i > 0 ? UI.c("#{app["error_count_24h"]} errors", :red) : UI.c("0 errors", :gray)
+          lines << "  #{UI.c(app["slug"], :cyan)}  #{app["name"]}  #{env_badge}  #{errors}"
+        end
+        lines << ""
+        lines << "Use: activerabbit use-app <slug>"
+        lines.join("\n")
+      end
+
+      def self.status_human(data)
+        top = data["top_issue"]
+        health_color = data["health"] == "ok" ? :green : :red
+        lines = [
+          "#{UI.c(data["name"], :bold)} (#{data["app"]})",
+          "",
+          "Health: #{UI.c(data["health"], health_color)}  Errors (24h): #{data["error_count_24h"]}  p95: #{data["p95_latency_ms"]} ms",
+          "Deploy: #{data["deploy_status"]}  Last: #{UI.relative_time(data["last_deploy_at"])}"
+        ]
+        if top
+          lines << ""
+          lines << UI.c("Top issue:", :bold)
+          lines << "  #{UI.severity(top["severity"])} #{top["title"]}"
+          lines << "  #{top["count"]} events · #{top["id"]}"
+        end
+        lines.join("\n")
+      end
+
+      def self.incidents_human(data)
+        list = data["incidents"] || []
+        return "No incidents found." if list.empty?
+
+        lines = []
+        lines << ""
+        list.each_with_index do |inc, idx|
+          severity = UI.severity(inc["severity"])
+          title = UI.truncate(inc["title"], 55)
+          time_ago = UI.relative_time(inc["last_seen_at"])
+          count = inc["count"].to_s.rjust(5)
+          status_icon = case inc["status"]
+                        when "wip" then UI.c("◐", :yellow)
+                        when "closed" then UI.c("✓", :green)
+                        else UI.c("●", :red)
+                        end
+
+          lines << "#{status_icon} #{severity} #{UI.c(inc["id"], :cyan)}"
+          lines << "  #{title}"
+          lines << "  #{UI.c(inc["endpoint"], :gray)}  #{UI.c(count, :bold)} events  #{UI.c(time_ago, :gray)}"
+          lines << "" if idx < list.size - 1
+        end
+        lines << ""
+        lines << UI.c("Use: activerabbit show <id>  or  activerabbit explain <id>", :gray)
+        lines.join("\n")
+      end
+
+      def self.incident_detail_human(data)
+        severity = UI.severity(data["severity"])
+        status_color = { "open" => :red, "wip" => :yellow, "closed" => :green }[data["status"]] || :gray
+
+        lines = []
+        lines << UI.box("#{data["exception_class"]}", [
+          "#{UI.c(data["message"], :bold)}",
+          "",
+          "#{severity} #{UI.c(data["status"].upcase, status_color)}  #{UI.c(data["id"], :cyan)}",
+          "",
+          "#{UI.c("Endpoint:", :gray)} #{data["endpoint"]}",
+          "#{UI.c("Count:", :gray)} #{data["count"]}  #{UI.c("Affected users:", :gray)} #{data["affected_users"]}",
+          "#{UI.c("First:", :gray)} #{UI.relative_time(data["first_seen_at"])}  #{UI.c("Last:", :gray)} #{UI.relative_time(data["last_seen_at"])}"
+        ])
+
+        lines << ""
+        lines << UI.c("Stack trace:", :bold)
+        Array(data["backtrace"]).first(8).each do |frame|
+          if frame.include?("app/")
+            lines << "  #{UI.c(frame, :cyan)}"
+          else
+            lines << "  #{UI.c(frame, :gray)}"
+          end
+        end
+        if Array(data["backtrace"]).size > 8
+          lines << "  #{UI.c("... #{data["backtrace"].size - 8} more frames", :gray)}"
+        end
+
+        if data["recent_events"]&.any?
+          lines << ""
+          lines << UI.c("Recent events:", :bold)
+          data["recent_events"].first(5).each do |evt|
+            lines << "  #{UI.relative_time(evt["at"])}  user:#{evt["user_id"]}  req:#{evt["request_id"]}"
+          end
+        end
+
+        lines << ""
+        lines << UI.c("Run: activerabbit explain #{data["id"]}", :gray)
+        lines.join("\n")
+      end
+
+      def self.explain_human(data)
+        lines = [
+          UI.c("#{data["title"]} (#{data["incident_id"]})", :bold),
+          "#{UI.severity(data["severity"])}  Confidence: #{(data["confidence_score"] * 100).to_i}%",
+          "",
+          UI.c("Root cause:", :bold),
+          "  #{data["root_cause"]}",
+          "",
+          UI.c("Suggested fix:", :bold),
+          "  #{data["suggested_fix"]}",
+          "",
+          "#{UI.c("Affected:", :gray)} #{Array(data["affected_endpoints"]).join(", ")}",
+          "#{UI.c("Regression risk:", :gray)} #{data["regression_risk"]}",
+          "#{UI.c("Tests to run:", :gray)} #{Array(data["tests_to_run"]).join(", ")}"
+        ]
+        lines.join("\n")
+      end
+
+      def self.trace_human(data)
+        lines = [
+          UI.c("Trace: #{data["endpoint"]}", :bold) + " (#{data["trace_id"]})",
+          "Duration: #{data["duration_ms"]} ms",
+          "",
+          UI.c("Spans:", :bold)
+        ]
+        (data["spans"] || []).each do |s|
+          bar_len = [s["percent"].to_i / 5, 1].max
+          bar = UI.c("█" * bar_len, :cyan) + UI.c("░" * (20 - bar_len), :gray)
+          lines << "  #{bar} #{s["duration_ms"].to_s.rjust(5)} ms  #{s["name"]}"
+        end
+        lines << ""
+        lines << UI.c("Bottlenecks:", :bold)
+        Array(data["bottlenecks"]).each { |b| lines << "  #{UI.c("·", :red)} #{b}" }
+        lines.join("\n")
+      end
+
+      def self.deploy_check_human(data)
+        ready_icon = data["ready"] ? UI.c("✓", :green) : UI.c("✗", :red)
+        lines = [
+          "Deploy check: #{ready_icon} #{data["ready"] ? "ready" : "not ready"}",
+          "Last deploy: #{UI.relative_time(data["last_deploy_at"])}",
+          "New errors since deploy: #{data["new_errors_since_deploy"]}"
+        ]
+        Array(data["warnings"]).each { |w| lines << "  #{UI.c("⚠", :yellow)} #{w}" }
+        lines.join("\n")
+      end
+
+      def self.doctor_human(data)
+        cfg_icon = data["config_ok"] ? UI.c("✓", :green) : UI.c("✗", :red)
+        api_icon = data["api_ok"] ? UI.c("✓", :green) : UI.c("✗", :red)
+        app_icon = data["app_ok"] ? UI.c("✓", :green) : UI.c("✗", :red)
+        [
+          "Config: #{cfg_icon}  API: #{api_icon}  App: #{app_icon}",
+          "",
+          data["message"]
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/activerabbit/ui.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  # Terminal UI helpers: colors, relative time, box drawing
+  module UI
+    COLORS = {
+      red:     "\e[31m",
+      green:   "\e[32m",
+      yellow:  "\e[33m",
+      blue:    "\e[34m",
+      magenta: "\e[35m",
+      cyan:    "\e[36m",
+      gray:    "\e[90m",
+      bold:    "\e[1m",
+      reset:   "\e[0m"
+    }.freeze
+
+    SEVERITY_COLORS = {
+      "critical" => :red,
+      "high"     => :red,
+      "medium"   => :yellow,
+      "low"      => :cyan,
+      "info"     => :gray
+    }.freeze
+
+    class << self
+      def color_enabled?
+        return @color_enabled if defined?(@color_enabled)
+
+        @color_enabled = $stdout.tty? && ENV["NO_COLOR"].nil?
+      end
+
+      def color_enabled=(val)
+        @color_enabled = val
+      end
+
+      def c(text, *styles)
+        return text.to_s unless color_enabled?
+
+        codes = styles.map { |s| COLORS[s] }.compact.join
+        "#{codes}#{text}#{COLORS[:reset]}"
+      end
+
+      def severity(level)
+        color = SEVERITY_COLORS[level.to_s.downcase] || :gray
+        padded = level.to_s.upcase.ljust(8)
+        c(padded, color, :bold)
+      end
+
+      def relative_time(iso_time)
+        return "—" if iso_time.nil? || iso_time.to_s.strip == ""
+
+        begin
+          t = Time.parse(iso_time.to_s)
+        rescue ArgumentError
+          return iso_time.to_s[0, 16]
+        end
+
+        diff = Time.now - t
+        if diff < 60
+          "just now"
+        elsif diff < 3600
+          "#{(diff / 60).to_i}m ago"
+        elsif diff < 86400
+          "#{(diff / 3600).to_i}h ago"
+        elsif diff < 604800
+          "#{(diff / 86400).to_i}d ago"
+        else
+          t.strftime("%b %d")
+        end
+      end
+
+      def truncate(str, len)
+        s = str.to_s
+        s.length > len ? "#{s[0, len - 1]}…" : s
+      end
+
+      def box(title, lines)
+        width = [title.length + 4, lines.map { |l| strip_ansi(l).length }.max || 40].max + 2
+        bar = "─" * width
+        out = []
+        out << "┌#{bar}┐"
+        out << "│ #{c(title, :bold)}#{' ' * (width - title.length - 1)}│"
+        out << "├#{bar}┤"
+        lines.each do |line|
+          plain_len = strip_ansi(line).length
+          padding = width - plain_len - 1
+          out << "│ #{line}#{' ' * [padding, 0].max}│"
+        end
+        out << "└#{bar}┘"
+        out.join("\n")
+      end
+
+      def strip_ansi(str)
+        str.to_s.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def prompt_choice(message, options)
+        $stderr.puts message
+        options.each_with_index do |opt, idx|
+          $stderr.puts "  #{c("#{idx + 1})", :cyan)} #{opt}"
+        end
+        $stderr.print c("Choice [1-#{options.size}]: ", :bold)
+        input = $stdin.gets&.to_s&.strip
+        idx = input.to_i - 1
+        return nil if idx < 0 || idx >= options.size
+
+        options[idx]
+      end
+    end
+  end
+end

data/lib/activerabbit/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRabbit
+  VERSION = "1.0.0"
+end

data/lib/activerabbit.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "activerabbit/version"
+require "activerabbit/ui"
+require "activerabbit/config"
+require "activerabbit/api_client"
+require "activerabbit/formatters"
+require "activerabbit/cli"
+require "activerabbit/commands"

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: activerabbit-cli
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ActiveRabbit
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: 'Production CLI for ActiveRabbit: status, incidents, explain, trace.
+  Human and machine-readable output (JSON, Markdown). Designed for developers and
+  AI agents.'
+email:
+- support@activerabbit.ai
+executables:
+- activerabbit
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/activerabbit
+- lib/activerabbit.rb
+- lib/activerabbit/api_client.rb
+- lib/activerabbit/cli.rb
+- lib/activerabbit/commands.rb
+- lib/activerabbit/config.rb
+- lib/activerabbit/formatters.rb
+- lib/activerabbit/ui.rb
+- lib/activerabbit/version.rb
+homepage: https://activerabbit.ai
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://activerabbit.ai
+  source_code_uri: https://github.com/activerabbit/activerabbit-cli
+  changelog_uri: https://github.com/activerabbit/activerabbit-cli/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.15
+signing_key:
+specification_version: 4
+summary: CLI for ActiveRabbit.ai — monitoring and issue analysis
+test_files: []