legionio 1.5.10 → 1.5.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a667cd060abef4731373441c150267a5cfff9851061823edf4ba2f11af957958
-  data.tar.gz: 667fa1b3e3779215514cbade8b8062a1e5a219fdbea51bbbae4e4e5a69c43c12
+  metadata.gz: 2e6a0551564a834f76d460cb9ffed6cbc5e48e6dfe15a377c64e3a2c0540ac99
+  data.tar.gz: 0daf3944544ddcc630fdba40b35b8430b968db898c5dbfcfb9b348cee752ba48
 SHA512:
-  metadata.gz: 5bae139c1dc0209987800907ce76b4c198ffff24de925e7fdfd2d2d0603bfbb6c095c4e863cc32510cac62fbf820ed850d8a05023d659a70c9bfd234c754f603
-  data.tar.gz: eea81ebd4a661ecd921aaf48c08259757ff434baea7f4685859bd2df6cac912e7ac89b09e4c64c3edc315549c485d3b46501609cd3cf2cd7d0c60a12491700c1
+  metadata.gz: 7bfab92636665b30da8655966c8d88a6bc112da34f96eae8968118917e0c7ca525ba8bf59ac98b62ede1cc41e704cb1b57707e9b4ff90e625ffe2bb6237111a5
+  data.tar.gz: 210b3a406307fed54591b2bc3bda9e0a35f8af8cad45788d1d1137d40db8b61637c2450b74b18a772d6065f3451031ca9d07ad3722ea7d209e1c22907afe120f

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Legion Changelog
 
+## [1.5.11] - 2026-03-25
+
+### Added
+- `legionio debug` command — full diagnostic dump (16 sections: versions, doctor, config, gems, extensions, RBAC, LLM, GAIA, transport, events, Apollo, remote/local Redis, PostgreSQL, RabbitMQ, API health) output as markdown or JSON, suitable for piping to an LLM session
+- `legionio update --cleanup` flag — removes old gem versions after update via `Gem::Uninstaller` (default: no cleanup)
+
+### Fixed
+- `update_command.rb` `snapshot_versions` now uses `find_all_by_name` + max version instead of `find_by_name`, which returned the already-activated (potentially stale) gem version
+- `service.rb` `setup_api` guard prevents duplicate Puma start when `@api_thread` is already alive
+
+### Changed
+- Bumped gemspec dependencies: legion-data >= 1.5.3, legion-gaia >= 0.9.24, legion-llm >= 0.5.8, legion-tty >= 0.4.35
+
 ## [1.5.10] - 2026-03-25
 
 ### Changed

data/legionio.gemspec

@@ -54,12 +54,14 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-cache', '>= 1.3.16'
   spec.add_dependency 'legion-crypt', '>= 1.4.12'
-  spec.add_dependency 'legion-data', '>= 1.5.0'
+  spec.add_dependency 'legion-data', '>= 1.5.3'
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.19'
   spec.add_dependency 'legion-transport', '>= 1.4.0'
 
-  spec.add_dependency 'legion-tty', '>= 0.4.34'
+  spec.add_dependency 'legion-gaia', '>= 0.9.24'
+  spec.add_dependency 'legion-llm', '>= 0.5.8'
+  spec.add_dependency 'legion-tty', '>= 0.4.35'
   spec.add_dependency 'lex-node'
 end

data/lib/legion/cli/debug_command.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'socket'
+require 'thor'
+
+module Legion
+  module CLI
+    class Debug < Thor
+      namespace 'debug'
+
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json, type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+      class_option :port, type: :numeric, default: 4567, desc: 'API port'
+      class_option :host, type: :string, default: '127.0.0.1', desc: 'API host'
+      class_option :config_dir, type: :string, desc: 'Config directory path'
+
+      desc 'dump', 'Full diagnostic dump (markdown, suitable for piping to LLM)'
+      default_task :dump
+      def dump
+        sections = {}
+
+        sections[:versions]    = section_versions
+        sections[:doctor]      = section_doctor
+        sections[:config]      = section_config
+        sections[:gems]        = section_gems
+        sections[:extensions]  = section_extensions
+        sections[:rbac]        = section_rbac
+        sections[:llm]         = section_llm
+        sections[:gaia]        = section_gaia
+        sections[:transport]   = section_transport
+        sections[:events]      = section_events
+        sections[:apollo]      = section_apollo
+        sections[:remote_redis] = section_remote_redis
+        sections[:local_redis]  = section_local_redis
+        sections[:postgresql]   = section_postgresql
+        sections[:rabbitmq]     = section_rabbitmq
+        sections[:api_health]   = section_api_health
+
+        if options[:json]
+          puts ::JSON.pretty_generate(sections)
+        else
+          render_markdown(sections)
+        end
+      end
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        private
+
+        def api_host
+          options[:host] || '127.0.0.1'
+        end
+
+        def api_port_number
+          options[:port] || 4567
+        end
+
+        def api_get(path)
+          uri  = URI("http://#{api_host}:#{api_port_number}#{path}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 3
+          http.read_timeout = 5
+          response = http.get(uri.request_uri)
+          ::JSON.parse(response.body, symbolize_names: true)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def load_settings
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level = 'error'
+          Connection.ensure_settings
+        rescue StandardError
+          nil
+        end
+
+        def section_versions
+          components = {}
+          components[:legionio] = defined?(Legion::VERSION) ? Legion::VERSION : 'unknown'
+          components[:ruby] = RUBY_VERSION
+          components[:platform] = RUBY_PLATFORM
+          components[:yjit] = defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+
+          %w[legion-transport legion-cache legion-crypt legion-data
+             legion-json legion-logging legion-settings
+             legion-llm legion-gaia legion-mcp legion-rbac legion-tty].each do |gem_name|
+            spec = Gem::Specification.find_by_name(gem_name)
+            components[gem_name.to_sym] = spec.version.to_s
+          rescue Gem::MissingSpecError
+            components[gem_name.to_sym] = 'not installed'
+          end
+
+          components
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_doctor
+          load_settings
+          require 'legion/cli/doctor_command'
+          Doctor::CHECKS.map do |name|
+            check = Doctor.const_get(name).new
+            result = check.run
+            { name: result.name, status: result.status, message: result.message }
+          rescue StandardError => e
+            { name: name.to_s, status: :error, message: e.message }
+          end
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_config
+          load_settings
+          settings_hash = Legion::Settings.loader.to_hash
+          redact_deep(settings_hash)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_gems
+          gems = {}
+          duplicates = []
+          Gem::Specification.each do |spec|
+            next unless spec.name.start_with?('legion-', 'lex-', 'legionio')
+
+            gems[spec.name] ||= []
+            gems[spec.name] << spec.version.to_s
+          end
+
+          gems.each do |name, versions|
+            duplicates << { name: name, versions: versions } if versions.size > 1
+          end
+
+          { total: gems.size, duplicates: duplicates,
+            versions: gems.transform_values { |v| v.max_by { |ver| Gem::Version.new(ver) } } }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_extensions
+          data = api_get('/api/extensions')
+          return data if data[:error]
+
+          exts = data[:data] || data[:extensions] || data
+          { count: exts.is_a?(Array) ? exts.size : nil, extensions: exts }
+        end
+
+        def section_rbac
+          api_get('/api/rbac/roles')
+        end
+
+        def section_llm
+          load_settings
+          require 'legion/llm'
+          Legion::Settings.merge_settings(:llm, Legion::LLM::Settings.default)
+          settings = Legion::LLM.settings
+          providers = settings[:providers] || {}
+          {
+            started:          defined?(Legion::LLM) && Legion::LLM.started?,
+            default_provider: settings[:default_provider],
+            default_model:    settings[:default_model],
+            providers:        providers.map { |name, cfg| { name: name, enabled: cfg[:enabled] } }
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_gaia
+          status = api_get('/api/gaia/status')
+          channels = api_get('/api/gaia/channels')
+          buffer = api_get('/api/gaia/buffer')
+          sessions = api_get('/api/gaia/sessions')
+          { status: status[:data] || status, channels: channels[:data] || channels,
+            buffer: buffer[:data] || buffer, sessions: sessions[:data] || sessions }
+        end
+
+        def section_transport
+          api_get('/api/transport/status')
+        end
+
+        def section_events
+          api_get('/api/events/recent?count=20')
+        end
+
+        def section_apollo
+          api_get('/api/apollo/stats')
+        end
+
+        def section_remote_redis
+          load_settings
+          cache_cfg = Legion::Settings[:cache]
+          return { error: 'no cache config' } unless cache_cfg.is_a?(Hash) && cache_cfg[:servers]
+
+          server = cache_cfg[:servers].first
+          host, port = server.to_s.split(':')
+          password = cache_cfg[:password]
+
+          redis_info(host, port.to_i, password)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_local_redis
+          load_settings
+          local_cfg = Legion::Settings[:cache_local]
+          return { error: 'no cache_local config' } unless local_cfg.is_a?(Hash) && local_cfg[:servers]
+
+          server = local_cfg[:servers].first
+          host, port = server.to_s.split(':')
+          password = local_cfg[:password]
+
+          redis_info(host, port.to_i, password)
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_postgresql
+          load_settings
+          data_cfg = Legion::Settings[:data]
+          return { error: 'no data config' } unless data_cfg.is_a?(Hash) && data_cfg[:creds]
+
+          creds = data_cfg[:creds]
+          require 'pg'
+          conn = PG.connect(
+            host: creds[:host], port: creds[:port] || 5432,
+            dbname: creds[:database], user: creds[:user], password: creds[:password],
+            connect_timeout: 5
+          )
+
+          db_size = conn.exec_params(
+            'SELECT pg_size_pretty(pg_database_size(current_database())) AS size'
+          ).first['size']
+          migration = conn.exec_params(
+            'SELECT version FROM schema_info ORDER BY version DESC LIMIT 1'
+          ).first
+          migration_version = migration ? migration['version'] : 'unknown'
+
+          tables = conn.exec_params(<<~SQL).to_a
+            SELECT tablename AS name,
+                   pg_size_pretty(pg_total_relation_size(quote_ident(tablename))) AS size,
+                   (SELECT n_live_tup FROM pg_stat_user_tables WHERE relname = tablename) AS rows
+            FROM pg_tables WHERE schemaname = 'public'
+            ORDER BY pg_total_relation_size(quote_ident(tablename)) DESC LIMIT 20
+          SQL
+
+          conn.close
+          { db_size: db_size, migration_version: migration_version, tables: tables }
+        rescue LoadError
+          { error: 'pg gem not available' }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_rabbitmq
+          load_settings
+          transport_cfg = Legion::Settings[:transport] || {}
+          host = transport_cfg[:host] || 'localhost'
+          mgmt_port = transport_cfg[:management_port] || 15_672
+          user = transport_cfg[:user] || 'guest'
+          pass = transport_cfg[:password] || 'guest'
+          vhost = transport_cfg[:vhost] || '/'
+
+          uri = URI("http://#{host}:#{mgmt_port}/api/overview")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.open_timeout = 3
+          http.read_timeout = 5
+          req = Net::HTTP::Get.new(uri)
+          req.basic_auth(user, pass)
+          resp = http.request(req)
+          overview = ::JSON.parse(resp.body, symbolize_names: true)
+
+          encoded_vhost = URI.encode_www_form_component(vhost)
+          queues_uri = URI("http://#{host}:#{mgmt_port}/api/queues/#{encoded_vhost}")
+          req2 = Net::HTTP::Get.new("#{queues_uri.path}?page=1&page_size=15&sort=messages&sort_reverse=true")
+          req2.basic_auth(user, pass)
+          resp2 = http.request(req2)
+          queues = ::JSON.parse(resp2.body, symbolize_names: true)
+
+          queue_list = queues.is_a?(Array) ? queues : (queues[:items] || [])
+
+          {
+            cluster_name:     overview[:cluster_name],
+            rabbitmq_version: overview[:rabbitmq_version],
+            erlang_version:   overview[:erlang_version],
+            message_stats:    overview[:message_stats],
+            queue_totals:     overview[:queue_totals],
+            object_totals:    overview[:object_totals],
+            top_queues:       queue_list.first(15).map do |q|
+              { name: q[:name], messages: q[:messages], consumers: q[:consumers] }
+            end
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def section_api_health
+          ready = api_get('/api/ready')
+          health = api_get('/api/health')
+          capacity = api_get('/api/capacity')
+          cost = api_get('/api/cost/summary')
+          { ready: ready, health: health, capacity: capacity, cost: cost }
+        end
+
+        def redis_info(host, port, password)
+          socket = TCPSocket.new(host, port)
+          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+          if password && !password.empty?
+            socket.write("AUTH #{password}\r\n")
+            auth_resp = socket.gets
+            return { error: "AUTH failed: #{auth_resp&.strip}" } unless auth_resp&.start_with?('+OK')
+          end
+
+          info = redis_command(socket, 'INFO memory')
+          dbsize_raw = redis_command(socket, 'DBSIZE')
+
+          socket.close
+
+          memory_lines = info.lines.select { |l| l.include?(':') }.to_h { |l| l.strip.split(':', 2) }
+          dbsize = dbsize_raw.to_s.scan(/\d+/).first
+
+          {
+            used_memory_human:       memory_lines['used_memory_human'],
+            used_memory_peak_human:  memory_lines['used_memory_peak_human'],
+            maxmemory_human:         memory_lines['maxmemory_human'],
+            mem_fragmentation_ratio: memory_lines['mem_fragmentation_ratio'],
+            dbsize:                  dbsize
+          }
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def redis_command(socket, cmd)
+          parts = cmd.split
+          socket.write("*#{parts.size}\r\n")
+          parts.each { |p| socket.write("$#{p.bytesize}\r\n#{p}\r\n") }
+
+          first = socket.gets
+          return '' unless first
+
+          case first[0]
+          when '+', ':' then first[1..].strip
+          when '-' then "ERROR: #{first[1..].strip}"
+          when '$'
+            len = first[1..].to_i
+            return '' if len.negative?
+
+            data = socket.read(len + 2)
+            data&.strip || ''
+          when '*'
+            count = first[1..].to_i
+            return '' if count.negative?
+
+            count.times.map { redis_read_bulk(socket) }.join("\n")
+          else
+            first.strip
+          end
+        end
+
+        def redis_read_bulk(socket)
+          header = socket.gets
+          return '' unless header&.start_with?('$')
+
+          len = header[1..].to_i
+          return '' if len.negative?
+
+          data = socket.read(len + 2)
+          data&.strip || ''
+        end
+
+        def redact_deep(obj)
+          case obj
+          when Hash
+            obj.each_with_object({}) do |(k, v), h|
+              h[k] = if k.to_s.match?(/password|secret|token|key|credential/i) && v.is_a?(String)
+                       '[REDACTED]'
+                     else
+                       redact_deep(v)
+                     end
+            end
+          when Array
+            obj.map { |v| redact_deep(v) }
+          else
+            obj
+          end
+        end
+
+        def render_markdown(sections)
+          puts '# LegionIO Diagnostic Dump'
+          puts
+          puts "Generated: #{Time.now.utc.iso8601}"
+          puts
+
+          md_section('Versions', sections[:versions])
+          md_section('Doctor Checks', sections[:doctor])
+          md_section('Configuration (redacted)', sections[:config])
+          md_section('Installed Gems', sections[:gems])
+          md_section('Loaded Extensions', sections[:extensions])
+          md_section('RBAC Roles', sections[:rbac])
+          md_section('LLM Status', sections[:llm])
+          md_section('GAIA Status', sections[:gaia])
+          md_section('Transport Status', sections[:transport])
+          md_section('Recent Events (last 20)', sections[:events])
+          md_section('Apollo Stats', sections[:apollo])
+          md_section('Remote Redis', sections[:remote_redis])
+          md_section('Local Redis', sections[:local_redis])
+          md_section('PostgreSQL', sections[:postgresql])
+          md_section('RabbitMQ', sections[:rabbitmq])
+          md_section('API Health', sections[:api_health])
+        end
+
+        def md_section(title, data)
+          puts "## #{title}"
+          puts
+          puts '```json'
+          puts ::JSON.pretty_generate(data)
+          puts '```'
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/update_command.rb

@@ -6,6 +6,7 @@ require 'rbconfig'
 require 'concurrent'
 require 'net/http'
 require 'json'
+require 'rubygems/uninstaller'
 
 module Legion
   module CLI
@@ -22,6 +23,7 @@ module Legion
       desc 'gems', 'Update Legion gems to latest versions (default)'
       default_task :gems
       option :dry_run, type: :boolean, default: false, desc: 'Show what would be updated without installing'
+      option :cleanup, type: :boolean, default: false, desc: 'Remove old gem versions after update'
       def gems
         out = formatter
         gem_bin = File.join(RbConfig::CONFIG['bindir'], 'gem')
@@ -44,6 +46,8 @@ module Legion
         else
           display_results(out, results, before, after)
         end
+
+        cleanup_old_gems(out, target_gems) if options[:cleanup] && !options[:dry_run]
       end
 
       no_commands do
@@ -66,11 +70,12 @@ module Legion
 
         def snapshot_versions(gem_names)
           gem_names.each_with_object({}) do |name, hash|
-            spec = Gem::Specification.find_by_name(name)
-            hash[name] = spec.version.to_s
-          rescue Gem::MissingSpecError => e
-            Legion::Logging.debug("UpdateCommand#snapshot_versions gem #{name} not found: #{e.message}") if defined?(Legion::Logging)
-            hash[name] = nil
+            specs = Gem::Specification.find_all_by_name(name)
+            hash[name] = if specs.empty?
+                           nil
+                         else
+                           specs.map(&:version).max.to_s
+                         end
           end
         end
 
@@ -174,6 +179,39 @@ module Legion
           suggest_detect(out)
         end
 
+        def cleanup_old_gems(out, gem_names)
+          Gem::Specification.reset
+          cleaned = 0
+
+          gem_names.each do |name|
+            specs = Gem::Specification.find_all_by_name(name).sort_by(&:version)
+            next if specs.size <= 1
+
+            latest = specs.pop
+            specs.each do |old_spec|
+              Gem::Uninstaller.new(
+                old_spec.name,
+                version:            old_spec.version,
+                ignore:             true,
+                executables:        false,
+                force:              true,
+                abort_on_dependent: false
+              ).uninstall
+              out.success("  Cleaned #{old_spec.name}-#{old_spec.version} (keeping #{latest.version})")
+              cleaned += 1
+            rescue StandardError => e
+              out.error("  Failed to clean #{old_spec.name}-#{old_spec.version}: #{e.message}")
+            end
+          end
+
+          out.spacer
+          if cleaned.positive?
+            out.success("Cleaned #{cleaned} old gem version(s)")
+          else
+            puts 'No old gem versions to clean'
+          end
+        end
+
         def suggest_detect(out)
           require 'legion/extensions/detect'
           missing = Legion::Extensions::Detect.missing

data/lib/legion/cli.rb

@@ -62,6 +62,7 @@ module Legion
     autoload :Apollo,      'legion/cli/apollo_command'
     autoload :TraceCommand, 'legion/cli/trace_command'
     autoload :Features,     'legion/cli/features_command'
+    autoload :Debug,        'legion/cli/debug_command'
 
     class Main < Thor
       def self.exit_on_failure?
@@ -342,6 +343,9 @@ module Legion
       desc 'features SUBCOMMAND', 'Install feature bundles (interactive selector)'
       subcommand 'features', Legion::CLI::Features
 
+      desc 'debug', 'Diagnostic dump for troubleshooting (pipe to LLM for analysis)'
+      subcommand 'debug', Legion::CLI::Debug
+
       desc 'tree', 'Print a tree of all available commands'
       def tree
         legion_print_command_tree(self.class, 'legion', '')

data/lib/legion/service.rb

@@ -236,6 +236,11 @@ module Legion
     end
 
     def setup_api
+      if @api_thread&.alive?
+        Legion::Logging.warn 'API already running, skipping duplicate setup_api call'
+        return
+      end
+
       require 'legion/api'
       api_settings = Legion::Settings[:api] || {}
       port = api_settings[:port] || 4567

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.5.10'
+  VERSION = '1.5.11'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.10
+  version: 1.5.11
 platform: ruby
 authors:
 - Esity
@@ -253,14 +253,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.5.3
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -317,20 +317,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.24
+- !ruby/object:Gem::Dependency
+  name: legion-llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.8
 - !ruby/object:Gem::Dependency
   name: legion-tty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.34
+        version: 0.4.35
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.34
+        version: 0.4.35
 - !ruby/object:Gem::Dependency
   name: lex-node
   requirement: !ruby/object:Gem::Requirement
@@ -555,6 +583,7 @@ files:
 - lib/legion/cli/dashboard/renderer.rb
 - lib/legion/cli/dashboard_command.rb
 - lib/legion/cli/dataset_command.rb
+- lib/legion/cli/debug_command.rb
 - lib/legion/cli/detect_command.rb
 - lib/legion/cli/do_command.rb
 - lib/legion/cli/docs_command.rb