legionio 1.4.199 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49f46da2cebfc684c3bfa9285698ed55e8d266bb4bdce293ab18fbf979496652
-  data.tar.gz: e290dd04b7341ebba8a1e567d17348930049ff16aa68409cfb8162db064225ff
+  metadata.gz: 610c8e32889fe2c4f1fe939e6281ea9a4ed47438723d47b605f6ce74b51a3f7c
+  data.tar.gz: c727fbf0febe067f634be639ed46a7642e2c47d5e3accadcb276b506f5f02c9a
 SHA512:
-  metadata.gz: 62876302ad244a1ac5e4679fe16d682bc21c7e4264bcc5400907c0fa171d463f83193888d247f6437f7be9c3c4544f1b3b79b9d46fbe32fa3afb6ba1255c1403
-  data.tar.gz: 64738b0d3b30dd28524c50b7090631f97fcdc6f29941cd566e2804a004834e924babe008406077c0214b46dfe67495c804641ce4343ee268fc836f66e83da1de
+  metadata.gz: 17acc62f2465c285639a2b1bce2a59f14555e89189aa5c3932d1b49f36dd5500a3a1441f0b0810f52ebecc1160d68c2e834ff852f1309872b2212404195c8bf9
+  data.tar.gz: e48c0a848e8bccc2ba4af5ad51c8f39a87b4825968329bae36f84d6a6f06b46492c57ce2b0c5f612f511ed360508488cbd06e44758461f7214803dd18026c628

data/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Legion Changelog
 
-## [1.4.199] - 2026-03-24
+## [1.5.0] - 2026-03-24
 
 ### Added
 - `legion setup agentic` — install full cognitive stack (legion-gaia + legion-llm + all transitive deps) in one command
@@ -9,6 +9,23 @@
 - `legion setup packs` — show installed/missing feature packs
 - `--dry-run` flag on all pack install commands
 - `legion detect` now recommends `legion setup agentic` when legion-gaia or legion-llm are missing
+- `legionio version --full` displays all installed lex-* extension versions
+- `legionio version` now lists all 13 legion-* gems with `(not installed)` for missing ones
+
+### Changed
+- Overhaul `legionio check` with proper namespace labels (Legion::Settings, Legion::Transport, etc.)
+- Each check returns connection detail strings (config dir, amqp:// URL, driver -> servers, adapter -> host:port/db)
+- Add Legion::Cache::Local and Legion::Data::Local checks with dependency chaining
+- Fix dependency skip logic to cascade through transitive dependencies (skip-on-skip, not just skip-on-fail)
+- Add privacy mode sub-check (`legionio check --privacy`)
+- Comment out Bootsnap.setup in exe/legion (matching exe/legionio)
+- Bump gemspec minimum: legion-data >= 1.5.0
+
+### Fixed
+- Runner log output now tagged with extension name (e.g. `[mesh][Runner]` instead of bare `[Runner]`)
+- Extension Transport and Routes builders use tagged `log` helper instead of bare `Legion::Logging`
+
+## [1.4.198] - 2026-03-24
 
 ### Changed
 - Comment out Bootsnap.setup in exe/legion (matching exe/legionio)

data/legionio.gemspec

@@ -54,7 +54,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-cache', '>= 1.3.11'
   spec.add_dependency 'legion-crypt', '>= 1.4.9'
-  spec.add_dependency 'legion-data', '>= 1.4.19'
+  spec.add_dependency 'legion-data', '>= 1.5.0'
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'

data/lib/legion/cli/check_command.rb

@@ -3,18 +3,32 @@
 module Legion
   module CLI
     module Check
-      CHECKS = %i[settings crypt transport cache data].freeze
+      CHECKS = %i[settings crypt transport cache cache_local data data_local].freeze
       EXTENSION_CHECKS = %i[extensions].freeze
       FULL_CHECKS = %i[api].freeze
 
+      CHECK_LABELS = {
+        settings:    'Legion::Settings',
+        crypt:       'Legion::Crypt',
+        transport:   'Legion::Transport',
+        cache:       'Legion::Cache',
+        cache_local: 'Legion::Cache::Local',
+        data:        'Legion::Data',
+        data_local:  'Legion::Data::Local',
+        extensions:  'Legion::Extensions',
+        api:         'Legion::API'
+      }.freeze
+
       # Dependencies: if a check fails, these dependents are skipped
       DEPENDS_ON = {
-        crypt:      :settings,
-        transport:  :settings,
-        cache:      :settings,
-        data:       :settings,
-        extensions: :transport,
-        api:        :transport
+        crypt:       :settings,
+        transport:   :settings,
+        cache:       :settings,
+        cache_local: :cache,
+        data:        :settings,
+        data_local:  :data,
+        extensions:  :transport,
+        api:         :transport
       }.freeze
 
       autoload :PrivacyCheck, 'legion/cli/check/privacy_check'
@@ -85,7 +99,7 @@ module Legion
 
           checks.each do |name|
             dep = DEPENDS_ON[name]
-            if dep && results[dep] && results[dep][:status] == 'fail'
+            if dep && results[dep] && %w[fail skip].include?(results[dep][:status])
               results[name] = { status: 'skip', error: "#{dep} failed" }
               print_result(formatter, name, results[name], options) unless options[:json]
               next
@@ -111,9 +125,9 @@ module Legion
 
         def run_check(name, options)
           start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-          send(:"check_#{name}", options)
+          detail = send(:"check_#{name}", options)
           elapsed = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(2)
-          { status: 'pass', time: elapsed }
+          { status: 'pass', time: elapsed, detail: detail }
         rescue StandardError, LoadError => e
           elapsed = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start).round(2)
           { status: 'fail', error: e.message, time: elapsed }
@@ -123,27 +137,82 @@ module Legion
           require 'legion/settings'
           dir = Connection.send(:resolve_config_dir)
           Legion::Settings.load(config_dir: dir)
+          dir || Legion::Settings.instance_variable_get(:@config_dir) || '(default)'
         end
 
         def check_crypt(_options)
           require 'legion/crypt'
           Legion::Crypt.start
+          vault_addr = ENV.fetch('VAULT_ADDR', nil)
+          connected = defined?(Legion::Crypt) && Legion::Crypt.respond_to?(:vault_connected?) && Legion::Crypt.vault_connected?
+          connected ? "Vault #{vault_addr || 'connected'}" : 'no Vault'
         end
 
         def check_transport(_options)
           require 'legion/transport'
           Legion::Settings.merge_settings('transport', Legion::Transport::Settings.default)
           Legion::Transport::Connection.setup
+          if Legion::Transport::Connection.lite_mode?
+            'InProcess (lite mode)'
+          else
+            ts = Legion::Settings[:transport] || {}
+            host = ts.dig(:connection, :host) || '127.0.0.1'
+            port = ts.dig(:connection, :port) || 5672
+            vhost = ts.dig(:connection, :vhost) || '/'
+            user = ts.dig(:connection, :user) || 'guest'
+            "amqp://#{user}@#{host}:#{port}#{vhost}"
+          end
         end
 
         def check_cache(_options)
           require 'legion/cache'
+          if defined?(Legion::Cache) && Legion::Cache.respond_to?(:using_memory?) && Legion::Cache.using_memory?
+            'Memory (lite mode)'
+          else
+            cs = Legion::Settings[:cache] || {}
+            driver = cs[:driver] || 'dalli'
+            servers = Array(cs[:servers] || cs[:server] || ['127.0.0.1'])
+            "#{driver} -> #{servers.join(', ')}"
+          end
+        end
+
+        def check_cache_local(_options)
+          raise 'Legion::Cache::Local not available' unless defined?(Legion::Cache::Local) && Legion::Cache::Local.respond_to?(:setup)
+
+          Legion::Cache::Local.setup
+          cs = Legion::Cache::Settings.respond_to?(:local) ? Legion::Cache::Settings.local : {}
+          driver = cs[:driver] || 'dalli'
+          servers = Array(cs[:servers] || cs[:server] || ['127.0.0.1'])
+          "#{driver} -> #{servers.join(', ')}"
         end
 
         def check_data(_options)
           require 'legion/data'
           Legion::Settings.merge_settings(:data, Legion::Data::Settings.default)
           Legion::Data.setup
+          ds = Legion::Settings[:data] || {}
+          adapter = ds[:adapter] || 'sqlite'
+          if adapter == 'sqlite'
+            db_path = ds[:database] || 'legion.db'
+            "sqlite -> #{db_path}"
+          else
+            host = ds[:host] || '127.0.0.1'
+            port = ds[:port]
+            database = ds[:database] || 'legion'
+            "#{adapter} -> #{host}#{":#{port}" if port}/#{database}"
+          end
+        end
+
+        def check_data_local(_options)
+          if defined?(Legion::Data::Local) && Legion::Data::Local.respond_to?(:setup)
+            Legion::Data::Local.setup unless Legion::Data::Local.respond_to?(:connected?) && Legion::Data::Local.connected?
+            db_path = Legion::Data::Local.respond_to?(:db_path) ? Legion::Data::Local.db_path : '~/.legionio/local.db'
+            "sqlite -> #{db_path}"
+          elsif defined?(Legion::Data)
+            'not configured'
+          else
+            raise 'Legion::Data not available'
+          end
         end
 
         def check_extensions(_options)
@@ -208,10 +277,18 @@ module Legion
           Legion::Cache.shutdown
         end
 
+        def shutdown_cache_local
+          Legion::Cache::Local.shutdown if defined?(Legion::Cache::Local) && Legion::Cache::Local.respond_to?(:shutdown)
+        end
+
         def shutdown_data
           Legion::Data.shutdown
         end
 
+        def shutdown_data_local
+          Legion::Data::Local.shutdown if defined?(Legion::Data::Local) && Legion::Data::Local.respond_to?(:shutdown)
+        end
+
         def shutdown_extensions
           Legion::Extensions.shutdown
         end
@@ -219,16 +296,17 @@ module Legion
         def shutdown_api; end
 
         def print_result(formatter, name, result, options)
-          label = name.to_s.ljust(14)
+          label = CHECK_LABELS.fetch(name, name.to_s).ljust(22)
           case result[:status]
           when 'pass'
-            line = "  #{label}#{formatter.colorize('pass', :green)}"
+            detail = result[:detail] ? "  #{formatter.colorize(result[:detail].to_s, :muted)}" : ''
+            line = "  #{label} #{formatter.colorize('pass', :green)}#{detail}"
             line += "  (#{result[:time]}s)" if options[:verbose]
           when 'fail'
-            line = "  #{label}#{formatter.colorize('FAIL', :red)}  #{result[:error]}"
+            line = "  #{label} #{formatter.colorize('FAIL', :red)}  #{result[:error]}"
             line += "  (#{result[:time]}s)" if options[:verbose]
           when 'skip'
-            line = "  #{label}#{formatter.colorize('skip', :yellow)}  #{result[:error]}"
+            line = "  #{label} #{formatter.colorize('skip', :yellow)}  #{result[:error]}"
           end
           puts line
         end

data/lib/legion/cli.rb

@@ -82,6 +82,13 @@ module Legion
         exit(1)
       end
 
+      LEGION_GEMS = %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 legion-ffi
+      ].freeze
+
       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 :verbose, type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
@@ -89,11 +96,15 @@ module Legion
 
       desc 'version', 'Show version information'
       map %w[-v --version] => :version
+      option :full, type: :boolean, default: false, desc: 'Include all installed lex-* extension versions'
       def version
         out = formatter
+        lexs = discovered_lexs
         if options[:json]
-          out.json(version: Legion::VERSION, ruby: RUBY_VERSION, platform: RUBY_PLATFORM,
-                   components: installed_components, extensions: discovered_lexs.size)
+          payload = { version: Legion::VERSION, ruby: RUBY_VERSION, platform: RUBY_PLATFORM,
+                      components: installed_components, extensions: lexs.size }
+          payload[:extension_versions] = lex_versions(lexs) if options[:full]
+          out.json(payload)
         else
           out.banner(version: Legion::VERSION)
           out.spacer
@@ -107,8 +118,15 @@ module Legion
           end
 
           out.spacer
-          lex_count = discovered_lexs.size
-          puts "  #{out.colorize("#{lex_count} extension(s)", :accent)} installed"
+          puts "  #{out.colorize("#{lexs.size} extension(s)", :accent)} installed"
+
+          if options[:full] && lexs.any?
+            out.spacer
+            out.header('Extensions')
+            lex_versions(lexs).each do |name, ver|
+              puts "  #{out.colorize(name.ljust(20), :label)} #{ver}"
+            end
+          end
         end
       end
 
@@ -405,20 +423,25 @@ module Legion
 
         def installed_components
           components = { legionio: Legion::VERSION }
-          %w[legion-transport legion-data legion-cache legion-crypt legion-json legion-logging legion-settings
-             legion-llm legion-gaia legion-tty].each do |gem_name|
-            spec = Gem::Specification.find_by_name(gem_name)
+          LEGION_GEMS.each do |gem_name|
             short = gem_name.sub('legion-', '')
+            spec = Gem::Specification.find_by_name(gem_name)
             components[short.to_sym] = spec.version.to_s
           rescue Gem::MissingSpecError => e
             Legion::Logging.debug("CLI#installed_components gem #{gem_name} not installed: #{e.message}") if defined?(Legion::Logging)
-            components[gem_name.sub('legion-', '').to_sym] = '(not installed)'
+            components[short.to_sym] = '(not installed)'
           end
           components
         end
 
         def discovered_lexs
-          Gem::Specification.all_names.select { |g| g.start_with?('lex-') }
+          Gem::Specification.select { |s| s.name.start_with?('lex-') }
+                            .group_by(&:name)
+                            .transform_values { |specs| specs.max_by(&:version) }
+        end
+
+        def lex_versions(lexs)
+          lexs.sort_by { |name, _| name }.to_h { |name, spec| [name, spec.version.to_s] }
         end
 
         def find_pidfile

data/lib/legion/extensions/builders/routes.rb

@@ -28,7 +28,7 @@ module Legion
 
             methods.each do |function|
               route_path = "#{extension_name}/#{runner_name}/#{function}"
-              Legion::Logging.info "[Routes] auto-route registered: POST /api/lex/#{route_path}" if defined?(Legion::Logging)
+              log.info "[Routes] auto-route registered: POST /api/lex/#{route_path}"
               @routes[route_path] = {
                 lex_name:     extension_name,
                 runner_name:  runner_name,

data/lib/legion/extensions/transport.rb

@@ -9,7 +9,7 @@ module Legion
       attr_accessor :exchanges, :queues, :consumers, :messages
 
       def build
-        Legion::Logging.debug "[Transport] build start: #{lex_name}" if defined?(Legion::Logging)
+        log.debug "[Transport] build start: #{lex_name}"
         @queues = []
         @exchanges = []
         @messages = []
@@ -22,10 +22,10 @@ module Legion
         build_e_to_q(additional_e_to_q)
         auto_create_dlx_exchange
         auto_create_dlx_queue
-        Legion::Logging.info "[Transport] built exchanges=#{@exchanges.count} queues=#{@queues.count} for #{lex_name}" if defined?(Legion::Logging)
+        log.info "[Transport] built exchanges=#{@exchanges.count} queues=#{@queues.count} for #{lex_name}"
       rescue StandardError => e
-        Legion::Logging.error "[Transport] build failed for #{lex_name}: #{e.message}"
-        Legion::Logging.error e.backtrace
+        log.error "[Transport] build failed for #{lex_name}: #{e.message}"
+        log.error e.backtrace
       end
 
       def generate_base_modules
@@ -49,7 +49,7 @@ module Legion
 
       def auto_create_exchange(exchange, default_exchange = false) # rubocop:disable Style/OptionalBooleanParameter
         if Object.const_defined? exchange
-          Legion::Logging.warn "#{exchange} is already defined"
+          log.warn "#{exchange} is already defined"
           return
         end
         return build_default_exchange if default_exchange
@@ -62,7 +62,7 @@ module Legion
 
       def auto_create_queue(queue)
         if Kernel.const_defined?(queue)
-          Legion::Logging.warn "#{queue} is already defined"
+          log.warn "#{queue} is already defined"
           return
         end
 

data/lib/legion/runner.rb

@@ -7,9 +7,11 @@ require 'legion/transport/messages/check_subtask'
 
 module Legion
   module Runner
-    def self.run(runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, catch_exceptions: false, **opts) # rubocop:disable Layout/LineLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/MethodLength, Metrics/PerceivedComplexity
+    def self.run(runner_class:, function:, task_id: nil, args: nil, check_subtask: true, generate_task: true, parent_id: nil, master_id: nil, catch_exceptions: false, **opts) # rubocop:disable Layout/LineLength, Metrics/CyclomaticComplexity, Metrics/ParameterLists, Metrics/MethodLength, Metrics/PerceivedComplexity
       started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      Legion::Logging.info "[Runner] start: #{runner_class}##{function} task_id=#{task_id}" if defined?(Legion::Logging)
+      lex_tag = derive_lex_tag(runner_class)
+      rlog = runner_logger(lex_tag)
+      rlog.info "[Runner] start: #{runner_class}##{function} task_id=#{task_id}"
       runner_class = Kernel.const_get(runner_class) if runner_class.is_a? String
 
       if task_id.nil? && generate_task
@@ -31,11 +33,11 @@ module Legion
 
       result = runner_class.send(function, **args)
     rescue Legion::Exception::HandledTask => e
-      Legion::Logging.debug "[Runner] HandledTask raised in #{runner_class}##{function}: #{e.message}" if defined?(Legion::Logging)
+      rlog.debug "[Runner] HandledTask raised in #{runner_class}##{function}: #{e.message}"
       status = 'task.exception'
       result = { error: {} }
     rescue StandardError => e
-      Legion::Logging.error "[Runner] exception in #{runner_class}##{function}: #{e.message}" if defined?(Legion::Logging)
+      rlog.error "[Runner] exception in #{runner_class}##{function}: #{e.message}"
       runner_class.handle_exception(e,
                                     **opts,
                                     runner_class:  runner_class,
@@ -50,7 +52,7 @@ module Legion
     ensure
       status = 'task.completed' if status.nil?
       duration_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-      Legion::Logging.info "[Runner] complete: #{runner_class}##{function} status=#{status} duration_ms=#{duration_ms}" if defined?(Legion::Logging)
+      rlog.info "[Runner] complete: #{runner_class}##{function} status=#{status} duration_ms=#{duration_ms}"
       Legion::Events.emit("task.#{status == 'task.completed' ? 'completed' : 'failed'}",
                           task_id: task_id, runner_class: runner_class.to_s, function: function, status: status)
       Legion::Runner::Status.update(task_id: task_id, status: status) unless task_id.nil?
@@ -76,10 +78,26 @@ module Legion
             detail:         { task_id: task_id, error: error_message }
           )
         rescue StandardError => e
-          Legion::Logging.debug("Audit in runner.run failed: #{e.message}") if defined?(Legion::Logging)
+          rlog.debug("Audit in runner.run failed: #{e.message}")
         end
       end
       return { success: true, status: status, result: result, task_id: task_id } # rubocop:disable Lint/EnsureReturn
     end
+
+    def self.derive_lex_tag(runner_class)
+      name = runner_class.is_a?(String) ? runner_class : runner_class.to_s
+      parts = name.split('::')
+      ext_idx = parts.index('Extensions')
+      return parts.last.downcase unless ext_idx && parts[ext_idx + 1]
+
+      parts[ext_idx + 1].gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                        .downcase
+    end
+
+    def self.runner_logger(tag)
+      @runner_loggers ||= {}
+      @runner_loggers[tag] ||= Legion::Logging::Logger.new(lex: tag)
+    end
   end
 end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.199
+  version: 1.5.0
 platform: ruby
 authors:
 - Esity
@@ -253,14 +253,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.19
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.19
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement