legionio 1.4.66 → 1.4.68

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce930ae41174649616f7c9793f36ba8d9c3b3d4655f778b34a10648715cdef35
-  data.tar.gz: 2cddda47aa6fb16bbaa6245daecb433ca572c60c2c689bfdb2aa7af6feb45349
+  metadata.gz: 1521235e6e865bd6d74f41b93c57e159de23d9dee0f044486c8059a6af780ab0
+  data.tar.gz: 7bdb02eb37ca2f03b9c0b6f7f494ebbb394d69f53ff83dd4bb5c1e27cb37e85e
 SHA512:
-  metadata.gz: 9c9481c8ec290af1037a6457268742bf05f1c8034073c57728726d426a8d995e5bb1a2619d1e1906cf69a1e7629019461a75d4cb4f1718243f5a2d4f5386f777
-  data.tar.gz: 6607b7b494cfeb13a33e1101584c679107a7616d58004ef41d81984056b20a88fdb3ad0377fa43734d9e411d27bc22be6b6629429730c52181fbfe370c261192
+  metadata.gz: 78a7171285d6a6eebda11d87d2782a68b6edb0dbc1f0be6d6034c1b4c7e535a5ae2dc1feb34ecbcc5af64d767759c7af7c78c1c50ed8672a1f08dea738c6b23b
+  data.tar.gz: 0b7c0e4d1298e13815383df8667d2b14debf66675c981002847fa19a01d0be6afa4314d811ba7cde7285ee46ddf37e9985e8a86745aef2b4b122d2a7dc1e16ac

data/.rubocop.yml

@@ -40,6 +40,7 @@ Metrics/BlockLength:
     - 'lib/legion/api/auth_worker.rb'
     - 'lib/legion/api/auth_human.rb'
     - 'lib/legion/cli/auth_command.rb'
+    - 'lib/legion/cli/detect_command.rb'
 
 Metrics/AbcSize:
   Max: 60

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # 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
+- `legionio detect` subcommand — scan environment and recommend extensions (requires lex-detect gem)
+  - `detect scan` (default) — show detected software and recommended extensions
+  - `detect catalog` — show full detection catalog
+  - `detect missing` — list extensions that should be installed
+  - `--install` flag to install missing extensions after scan
+  - `--json` output mode
+- `legionio update` now suggests new extensions via lex-detect after updating gems
+
 ## [1.4.66] - 2026-03-18
 
 ### Fixed

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/detect_command.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'legion/cli/output'
+
+module Legion
+  module CLI
+    class Detect < Thor
+      namespace 'detect'
+
+      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'
+
+      default_task :scan
+
+      desc 'scan', 'Scan environment and recommend extensions (default)'
+      option :install, type: :boolean, default: false, desc: 'Install missing extensions after scan'
+      option :dry_run, type: :boolean, default: false, desc: 'Show what would be installed without installing'
+      def scan
+        out = formatter
+        require_detect_gem
+
+        results = Legion::Extensions::Detect.scan
+
+        if options[:json]
+          out.json(detections: results)
+        else
+          display_detections(out, results)
+          install_missing(out) if options[:install]
+        end
+      end
+
+      desc 'catalog', 'Show the full detection catalog'
+      def catalog
+        out = formatter
+        require_detect_gem
+
+        catalog = Legion::Extensions::Detect.catalog
+
+        if options[:json]
+          catalog_data = catalog.map do |rule|
+            { name: rule[:name], extensions: rule[:extensions],
+              signals: rule[:signals].map { |s| "#{s[:type]}:#{s[:match]}" } }
+          end
+          out.json(catalog: catalog_data)
+        else
+          out.header('Detection Catalog')
+          out.spacer
+          catalog.each do |rule|
+            signals = rule[:signals].map { |s| "#{s[:type]}:#{s[:match]}" }.join(', ')
+            extensions = rule[:extensions].join(', ')
+            puts "  #{out.colorize(rule[:name].ljust(20), :label)} #{extensions.ljust(30)} #{signals}"
+          end
+          out.spacer
+          puts "  #{catalog.size} detection rules"
+        end
+      end
+
+      desc 'missing', 'List extensions that should be installed but are not'
+      def missing
+        out = formatter
+        require_detect_gem
+
+        missing_gems = Legion::Extensions::Detect.missing
+
+        if options[:json]
+          out.json(missing: missing_gems)
+        elsif missing_gems.empty?
+          out.success('All detected extensions are installed')
+        else
+          out.header('Missing Extensions')
+          missing_gems.each { |name| puts "  gem install #{name}" }
+          out.spacer
+          puts "  #{missing_gems.size} extension(s) recommended"
+          puts "  Run 'legionio detect --install' to install them"
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        private
+
+        def require_detect_gem
+          require 'legion/extensions/detect'
+        rescue LoadError => e
+          formatter.error("lex-detect gem not installed: #{e.message}")
+          puts '  Install with: gem install lex-detect'
+          raise SystemExit, 1
+        end
+
+        def display_detections(out, results)
+          if results.empty?
+            out.detail('No software detected that maps to Legion extensions.')
+            return
+          end
+
+          out.header('Environment Detection')
+          out.spacer
+
+          installed_count = 0
+          total_count = 0
+
+          results.each do |detection|
+            signals = detection[:matched_signals].join(', ')
+            detection[:extensions].each do |ext|
+              total_count += 1
+              is_installed = detection[:installed][ext]
+              installed_count += 1 if is_installed
+              status = is_installed ? out.colorize('installed', :success) : out.colorize('missing', :error)
+              puts "  #{out.colorize(detection[:name].ljust(20), :label)} #{signals.ljust(35)} #{ext.ljust(25)} #{status}"
+            end
+          end
+
+          out.spacer
+          puts "  #{installed_count} of #{total_count} extension(s) installed"
+        end
+
+        def install_missing(out)
+          missing_gems = Legion::Extensions::Detect.missing
+          return if missing_gems.empty?
+
+          out.spacer
+          if options[:dry_run]
+            out.header('Would install')
+            missing_gems.each { |name| puts "  #{name}" }
+            return
+          end
+
+          out.header('Installing missing extensions')
+          result = Legion::Extensions::Detect.install_missing!
+
+          result[:installed].each { |name| out.success("  Installed #{name}") }
+          result[:failed].each { |f| out.error("  Failed: #{f[:name]} — #{f[:error]}") }
+
+          out.spacer
+          if result[:failed].empty?
+            out.success("#{result[:installed].size} extension(s) installed")
+          else
+            out.warn("#{result[:installed].size} installed, #{result[:failed].size} failed")
+          end
+        end
+      end
+    end
+  end
+end

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]
@@ -127,6 +128,21 @@ module Legion
             puts 'All gems are up to date'
           end
           out.error("#{failed.size} gem(s) failed to update") if failed.any?
+
+          suggest_detect(out)
+        end
+
+        def suggest_detect(out)
+          require 'legion/extensions/detect'
+          missing = Legion::Extensions::Detect.missing
+          return if missing.empty?
+
+          out.spacer
+          puts "  #{missing.size} new extension(s) recommended based on your environment:"
+          missing.each { |name| puts "    gem install #{name}" }
+          puts "  Run 'legionio detect --install' to install them"
+        rescue LoadError
+          nil
         end
       end
     end

data/lib/legion/cli.rb

@@ -35,12 +35,14 @@ module Legion
     autoload :Auth,       'legion/cli/auth_command'
     autoload :Rbac,       'legion/cli/rbac_command'
     autoload :Audit,      'legion/cli/audit_command'
+    autoload :Detect,     'legion/cli/detect_command'
     autoload :Update,     'legion/cli/update_command'
     autoload :Init,       'legion/cli/init_command'
     autoload :Skill,      'legion/cli/skill_command'
     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'
 
@@ -59,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
@@ -211,6 +214,9 @@ module Legion
       desc 'audit SUBCOMMAND', 'Audit log inspection and verification'
       subcommand 'audit', Legion::CLI::Audit
 
+      desc 'detect', 'Scan environment and recommend extensions'
+      subcommand 'detect', Legion::CLI::Detect
+
       desc 'update', 'Update Legion gems to latest versions'
       subcommand 'update', Legion::CLI::Update
 
@@ -229,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
 
@@ -300,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.66'
+  VERSION = '1.4.68'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.66
+  version: 1.4.68
 platform: ruby
 authors:
 - Esity
@@ -430,6 +430,7 @@ files:
 - lib/legion/cli/dashboard/data_fetcher.rb
 - lib/legion/cli/dashboard/renderer.rb
 - lib/legion/cli/dashboard_command.rb
+- lib/legion/cli/detect_command.rb
 - lib/legion/cli/doctor/bundle_check.rb
 - lib/legion/cli/doctor/cache_check.rb
 - lib/legion/cli/doctor/config_check.rb
@@ -483,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