legionio 1.4.67 → 1.4.68

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a91ac55fb8db8f7105267bc77653cfd6c1a834a702fe6197a0e3687a889c841b
-  data.tar.gz: 7819aaa4e4dadb1e12e7f8741f57549ca6e8e801cc22aa472835c95cc16332df
+  metadata.gz: 1521235e6e865bd6d74f41b93c57e159de23d9dee0f044486c8059a6af780ab0
+  data.tar.gz: 7bdb02eb37ca2f03b9c0b6f7f494ebbb394d69f53ff83dd4bb5c1e27cb37e85e
 SHA512:
-  metadata.gz: a3d119331cd7741a3a5ec70b31ff224be0c74732334f200a38e4392eefd04cf1dc6846fc34a712ac6c6512f6baf45de9a83e26b8d0be723b14ab23efe05c1797
-  data.tar.gz: 3d2b1ff8e85f33cbcbbaceb60d8f60bfc176d23abb6c85c5212fc0ce810aeb588a964b51efef38832c049aa16efd940944da0f872be4e4178f5b611836a11151
+  metadata.gz: 78a7171285d6a6eebda11d87d2782a68b6edb0dbc1f0be6d6034c1b4c7e535a5ae2dc1feb34ecbcc5af64d767759c7af7c78c1c50ed8672a1f08dea738c6b23b
+  data.tar.gz: 0b7c0e4d1298e13815383df8667d2b14debf66675c981002847fa19a01d0be6afa4314d811ba7cde7285ee46ddf37e9985e8a86745aef2b4b122d2a7dc1e16ac

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Legion Changelog
 
+## [1.4.68] - 2026-03-19
+
+### Added
+- `legionio llm` subcommand for LLM provider diagnostics
+  - `llm status` (default) — show LLM state, enabled providers, routing, system memory
+  - `llm providers` — list all providers with enabled/disabled and reachability status
+  - `llm models` — list available models per enabled provider (Ollama discovery + cloud defaults)
+  - `llm ping` — test connectivity to each enabled provider with latency measurement
+  - All subcommands support `--json` output
+- `legionio version` now shows legion-llm, legion-gaia, and legion-tty in components list
+- `legionio version --json` now includes components hash and extension count
+
+### Fixed
+- `legionio update` now correctly detects gem version changes (was showing "already latest" for every gem due to stale in-memory gem spec cache after subprocess install)
+
 ## [1.4.67] - 2026-03-18
 
 ### Added

data/CLAUDE.md

@@ -9,7 +9,7 @@ The primary gem for the LegionIO framework. An extensible async job engine for s
 
 **GitHub**: https://github.com/LegionIO/LegionIO
 **Gem**: `legionio`
-**Version**: 1.4.65
+**Version**: 1.4.67
 **License**: Apache-2.0
 **Docker**: `legionio/legion`
 **Ruby**: >= 3.4
@@ -501,9 +501,11 @@ legion
 | `bootsnap` (>= 1.18) | YARV bytecode + load-path caching |
 | `oj` (>= 3.16) | Fast JSON (C extension) |
 | `puma` (>= 6.0) | HTTP server for API |
+| `rackup` (>= 2.0) | Rack server launcher for MCP HTTP transport |
 | `mcp` (~> 0.8) | MCP server SDK |
 | `reline` (>= 0.5) | Interactive line editing for chat REPL |
 | `rouge` (>= 4.0) | Syntax highlighting for chat markdown rendering |
+| `tty-spinner` (~> 0.9) | Spinner animation for CLI loading states |
 | `sinatra` (>= 4.0) | HTTP API framework |
 | `thor` (>= 1.3) | CLI framework |
 

data/README.md

@@ -14,7 +14,7 @@ Schedule tasks, chain services into dependency graphs, run them concurrently via
          ╰──────────────────────────────────────╯
 ```
 
-**Ruby >= 3.4** | **v1.4.61** | **Apache-2.0** | [@Esity](https://github.com/Esity)
+**Ruby >= 3.4** | **v1.4.67** | **Apache-2.0** | [@Esity](https://github.com/Esity)
 
 ---
 
@@ -83,6 +83,7 @@ gem 'legionio'
 | `legion-llm` | AI chat, commit, review, agents, multi-provider LLM routing |
 | `legion-cache` | Redis/Memcached caching for extensions |
 | `legion-crypt` | Vault integration, encryption, JWT auth |
+| `legion-tty` | TTY UI components (spinners, tables, prompts) |
 
 ## Infrastructure
 
@@ -487,7 +488,7 @@ Each phase registers with `Legion::Readiness`. All phases are individually toggl
 git clone https://github.com/LegionIO/LegionIO.git
 cd LegionIO
 bundle install
-bundle exec rspec       # 1379 examples, 0 failures
+bundle exec rspec       # 0 failures
 bundle exec rubocop     # 0 offenses
 ```
 

data/lib/legion/cli/llm_command.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module Legion
+  module CLI
+    class Llm < Thor
+      namespace 'llm'
+
+      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 :verbose,    type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
+      class_option :config_dir, type: :string,  desc: 'Config directory path'
+
+      desc 'status', 'Show LLM subsystem status and provider health'
+      default_task :status
+      def status
+        out = formatter
+        boot_llm_settings
+
+        data = collect_status
+        if options[:json]
+          out.json(data)
+        else
+          show_status(out, data)
+        end
+      end
+
+      desc 'providers', 'List configured LLM providers'
+      def providers
+        out = formatter
+        boot_llm_settings
+
+        data = collect_providers
+        if options[:json]
+          out.json(providers: data)
+        else
+          show_providers(out, data)
+        end
+      end
+
+      desc 'models', 'List available models per provider'
+      def models
+        out = formatter
+        boot_llm_settings
+
+        data = collect_models
+        if options[:json]
+          out.json(models: data)
+        else
+          show_models(out, data)
+        end
+      end
+
+      desc 'ping', 'Test connectivity to each enabled provider'
+      option :timeout, type: :numeric, default: 15, desc: 'Timeout per provider in seconds'
+      def ping
+        out = formatter
+        boot_llm(out)
+
+        results = ping_all_providers(out)
+        if options[:json]
+          out.json(results: results)
+        else
+          show_ping_results(out, results)
+        end
+      end
+
+      no_commands do # rubocop:disable Metrics/BlockLength
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def boot_llm_settings
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level = options[:verbose] ? 'debug' : 'error'
+          Connection.ensure_settings
+          require 'legion/llm'
+          Legion::Settings.merge_settings(:llm, Legion::LLM::Settings.default)
+        end
+
+        def boot_llm(out)
+          boot_llm_settings
+          out.header('Starting LLM subsystem...') unless options[:json]
+          Legion::LLM.start
+        rescue StandardError => e
+          out.error("LLM start failed: #{e.message}") unless options[:json]
+        end
+
+        def llm_settings
+          Legion::LLM.settings
+        end
+
+        def collect_status
+          providers_cfg = llm_settings[:providers] || {}
+          enabled = providers_cfg.select { |_, c| c[:enabled] }
+          started = defined?(Legion::LLM) && Legion::LLM.started?
+
+          {
+            started:          started,
+            default_model:    llm_settings[:default_model],
+            default_provider: llm_settings[:default_provider],
+            enabled_count:    enabled.size,
+            total_count:      providers_cfg.size,
+            providers:        collect_providers,
+            routing:          collect_routing,
+            system:           collect_system
+          }
+        end
+
+        def collect_providers
+          providers_cfg = llm_settings[:providers] || {}
+          providers_cfg.map do |name, cfg|
+            {
+              name:          name,
+              enabled:       cfg[:enabled] == true,
+              default_model: cfg[:default_model],
+              reachable:     check_reachable(name, cfg)
+            }
+          end
+        end
+
+        def check_reachable(name, cfg)
+          case name
+          when :ollama
+            return false unless cfg[:enabled]
+
+            base = cfg[:base_url] || 'http://localhost:11434'
+            uri = URI(base)
+            Socket.tcp(uri.host, uri.port, connect_timeout: 2) { true }
+          when :bedrock
+            return nil unless cfg[:enabled]
+
+            cfg[:bearer_token] || (cfg[:api_key] && cfg[:secret_key]) ? :credentials_present : false
+          else
+            return nil unless cfg[:enabled]
+
+            cfg[:api_key] ? :credentials_present : false
+          end
+        rescue StandardError
+          false
+        end
+
+        def collect_routing
+          return { enabled: false } unless defined?(Legion::LLM::Router)
+
+          {
+            enabled:    Legion::LLM::Router.routing_enabled?,
+            local_tier: Legion::LLM::Router.tier_available?(:local),
+            fleet_tier: Legion::LLM::Router.tier_available?(:fleet),
+            cloud_tier: Legion::LLM::Router.tier_available?(:cloud)
+          }
+        rescue StandardError
+          { enabled: false }
+        end
+
+        def collect_system
+          return {} unless defined?(Legion::LLM::Discovery::System)
+
+          Legion::LLM::Discovery::System.refresh! if Legion::LLM::Discovery::System.stale?
+          {
+            platform:        Legion::LLM::Discovery::System.platform,
+            total_memory_mb: Legion::LLM::Discovery::System.total_memory_mb,
+            avail_memory_mb: Legion::LLM::Discovery::System.available_memory_mb,
+            memory_pressure: Legion::LLM::Discovery::System.memory_pressure?
+          }
+        rescue StandardError
+          {}
+        end
+
+        def collect_models
+          providers_cfg = llm_settings[:providers] || {}
+          result = {}
+
+          providers_cfg.each do |name, cfg|
+            next unless cfg[:enabled]
+
+            models = [cfg[:default_model]].compact
+            if name == :ollama && defined?(Legion::LLM::Discovery::Ollama)
+              begin
+                Legion::LLM::Discovery::Ollama.refresh! if Legion::LLM::Discovery::Ollama.stale?
+                discovered = Legion::LLM::Discovery::Ollama.model_names
+                models = discovered unless discovered.empty?
+              rescue StandardError
+                # fall back to default_model
+              end
+            end
+            result[name] = models
+          end
+          result
+        end
+
+        def ping_all_providers(out)
+          providers_cfg = llm_settings[:providers] || {}
+          enabled = providers_cfg.select { |_, c| c[:enabled] }
+
+          if enabled.empty?
+            out.warn('No providers enabled') unless options[:json]
+            return []
+          end
+
+          enabled.map do |name, cfg|
+            ping_one_provider(out, name, cfg)
+          end
+        end
+
+        def ping_one_provider(out, name, cfg)
+          model = cfg[:default_model]
+          return { provider: name, status: 'skip', message: 'no default model configured', latency_ms: nil } unless model
+
+          out.header("  Pinging #{name} (#{model})...") unless options[:json]
+          t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+          response = RubyLLM.chat(model: model, provider: name).ask('Respond with only the word: pong')
+          elapsed = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round
+
+          content = response.content.to_s.strip
+          success = content.downcase.include?('pong')
+
+          if success
+            out.success("  #{name}: pong (#{elapsed}ms)") unless options[:json]
+          else
+            out.warn("  #{name}: unexpected response (#{elapsed}ms): #{content[0..80]}") unless options[:json]
+          end
+
+          { provider: name, status: success ? 'ok' : 'unexpected', response: content[0..80],
+            model: model, latency_ms: elapsed }
+        rescue StandardError => e
+          elapsed = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round if t0
+
+          out.error("  #{name}: #{e.message}") unless options[:json]
+          { provider: name, status: 'error', message: e.message, model: model, latency_ms: elapsed }
+        end
+
+        def show_status(out, data)
+          out.header('LLM Status')
+          out.detail({
+                       'Started'           => data[:started].to_s,
+                       'Default Provider'  => (data[:default_provider] || '(none)').to_s,
+                       'Default Model'     => (data[:default_model] || '(none)').to_s,
+                       'Providers Enabled' => "#{data[:enabled_count]}/#{data[:total_count]}"
+                     })
+
+          out.spacer
+          show_providers(out, data[:providers])
+
+          routing = data[:routing] || {}
+          if routing[:enabled]
+            out.spacer
+            out.header('Routing')
+            out.detail({
+                         'Enabled'    => routing[:enabled].to_s,
+                         'Local Tier' => routing[:local_tier].to_s,
+                         'Fleet Tier' => routing[:fleet_tier].to_s,
+                         'Cloud Tier' => routing[:cloud_tier].to_s
+                       })
+          end
+
+          sys = data[:system] || {}
+          return if sys.empty?
+
+          out.spacer
+          out.header('System')
+          out.detail({
+                       'Platform'         => (sys[:platform] || 'unknown').to_s,
+                       'Total Memory'     => sys[:total_memory_mb] ? "#{sys[:total_memory_mb]} MB" : 'unknown',
+                       'Available Memory' => sys[:avail_memory_mb] ? "#{sys[:avail_memory_mb]} MB" : 'unknown',
+                       'Memory Pressure'  => sys[:memory_pressure].to_s
+                     })
+        end
+
+        def show_providers(out, providers_data)
+          out.header('Providers')
+          providers_data.each do |p|
+            status = if p[:enabled]
+                       reach = p[:reachable]
+                       case reach
+                       when true then 'enabled, reachable'
+                       when :credentials_present then 'enabled, credentials present'
+                       when false then 'enabled, unreachable'
+                       else 'enabled'
+                       end
+                     else
+                       'disabled'
+                     end
+
+            color = p[:enabled] ? :green : :muted
+            name_str = p[:name].to_s.ljust(12)
+            model_str = p[:default_model] ? " (#{p[:default_model]})" : ''
+            puts "  #{out.colorize(name_str, :label)}#{out.colorize(status, color)}#{model_str}"
+          end
+        end
+
+        def show_models(out, models_data)
+          out.header('Available Models')
+          if models_data.empty?
+            out.warn('No providers enabled')
+            return
+          end
+
+          models_data.each do |provider, model_list|
+            out.spacer
+            puts "  #{out.colorize(provider.to_s, :accent)} (#{model_list.size} model#{'s' unless model_list.size == 1})"
+            model_list.each { |m| puts "    #{m}" }
+          end
+        end
+
+        def show_ping_results(out, results)
+          return if results.empty?
+
+          out.spacer
+          out.header('Ping Results')
+          passed = 0
+          failed = 0
+
+          results.each do |r|
+            case r[:status]
+            when 'ok'
+              passed += 1
+            when 'skip'
+              puts "  #{out.colorize(r[:provider].to_s.ljust(12), :label)}#{out.colorize('skipped', :muted)} #{r[:message]}"
+            else
+              failed += 1
+            end
+          end
+
+          out.spacer
+          if failed.zero?
+            out.success("#{passed} provider(s) responding")
+          else
+            out.error("#{failed} provider(s) failed, #{passed} responding")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/update_command.rb

@@ -33,6 +33,7 @@ module Legion
 
         before = snapshot_versions(target_gems)
         results = update_gems(target_gems, gem_bin, dry_run: options[:dry_run])
+        Gem::Specification.reset unless options[:dry_run]
         after = options[:dry_run] ? before : snapshot_versions(target_gems)
 
         if options[:json]

data/lib/legion/cli.rb

@@ -42,6 +42,7 @@ module Legion
     autoload :Cost,        'legion/cli/cost_command'
     autoload :Marketplace, 'legion/cli/marketplace_command'
     autoload :Notebook,    'legion/cli/notebook_command'
+    autoload :Llm,         'legion/cli/llm_command'
     autoload :Tty,         'legion/cli/tty_command'
     autoload :Interactive, 'legion/cli/interactive'
 
@@ -60,7 +61,8 @@ module Legion
       def version
         out = formatter
         if options[:json]
-          out.json(version: Legion::VERSION, ruby: RUBY_VERSION, platform: RUBY_PLATFORM)
+          out.json(version: Legion::VERSION, ruby: RUBY_VERSION, platform: RUBY_PLATFORM,
+                   components: installed_components, extensions: discovered_lexs.size)
         else
           out.banner(version: Legion::VERSION)
           out.spacer
@@ -233,6 +235,9 @@ module Legion
       desc 'notebook', 'Read and export Jupyter notebooks'
       subcommand 'notebook', Legion::CLI::Notebook
 
+      desc 'llm', 'LLM provider diagnostics (status, ping, models)'
+      subcommand 'llm', Legion::CLI::Llm
+
       desc 'tty', 'Rich terminal UI (onboarding, AI chat, dashboard)'
       subcommand 'tty', Legion::CLI::Tty
 
@@ -304,7 +309,8 @@ module Legion
 
         def installed_components
           components = { legionio: Legion::VERSION }
-          %w[legion-transport legion-data legion-cache legion-crypt legion-json legion-logging legion-settings].each do |gem_name|
+          %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)
             short = gem_name.sub('legion-', '')
             components[short.to_sym] = spec.version.to_s

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.67
+  version: 1.4.68
 platform: ruby
 authors:
 - Esity
@@ -484,6 +484,7 @@ files:
 - lib/legion/cli/lex/templates/runner_spec.erb
 - lib/legion/cli/lex_command.rb
 - lib/legion/cli/lex_templates.rb
+- lib/legion/cli/llm_command.rb
 - lib/legion/cli/marketplace_command.rb
 - lib/legion/cli/mcp_command.rb
 - lib/legion/cli/memory_command.rb