legion-tty 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea1c7546376e19d51fa1dde5e9f01184b74d41889c9f131f511aa90f634652d9
-  data.tar.gz: d1c354bb8dcbb056429d4e5eeaafbe7acc7fedaf15cc990ff96ec5d1f2561f6b
+  metadata.gz: 56a5f810aa64c98df76de0ed9f8b6637d2e18773f684158f6320f610f0b3f212
+  data.tar.gz: cf98c2b4cd4c37ee03e0e59067182f6237f9144d482ba2259a55b825bd4ef840
 SHA512:
-  metadata.gz: 45ddd593ac68b8bdac3b28497f3f60120ed09078b4d3a1d6a870b5a5ffa0797fb2c7debfbe8ee48d0edf87b30a64b43c60195c710adddfdc7eb2b6c55d3d7b85
-  data.tar.gz: da55989963a0b796421c8050d8d434e7be6a331a7a6cd379f0d16a77a3859e21a49ca37a82468dabdf1f03c78936fb8609526d549f7b52472b4c44cc86f8fa13
+  metadata.gz: e914e40a1b9ed5e0672c5e366cbe052bd7f372e8786e23b4455c998c99a4ef27f58fb3655ddfe3f8ef8d788ffc07b32671f03f6d6b754354c830ed9ef6fb076c
+  data.tar.gz: 4b94d15261c0d5bc1e3ecf783fb9235167df51fb9154450087c7cef6e6ec3e45a1a396db683b1c79640c9703069a5c725b64433162e36603a3afd60d0070322f

data/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## [0.2.5] - 2026-03-18
+
+### Added
+- Bootstrap config auto-import: detects `LEGIONIO_BOOTSTRAP_CONFIG` env var during onboarding
+- Fetches config from local file or HTTP/HTTPS URL (raw JSON or base64-encoded)
+- Splits top-level keys into individual settings files (`~/.legionio/settings/{key}.json`)
+- Deep merges with existing config files if present
+- Bootstrap summary line in reveal box showing imported sections
+- 14 new specs (374 total)
+
+## [0.2.4] - 2026-03-18
+
+### Added
+- Cache service awakening: detects running Redis/Memcached, offers to activate if missing
+- GAIA daemon discovery: checks for running legionio daemon, offers to start it
+- Cinematic typed prompts: "extending neural pathways", "GAIA is awake", "cognitive threads synchronized"
+- Cache and GAIA status lines in reveal summary box
+- 46 new specs (360 total)
+
+## [0.2.3] - 2026-03-18
+
+### Added
+- Vault LDAP auth step in onboarding: prompts to connect to configured vault clusters
+- Default username from Kerberos samaccountname or `$USER`, hidden password input
+- `WizardPrompt#ask_secret` (masked) and `#ask_with_default` methods
+- Vault cluster connection status in reveal summary box
+- 26 new specs for vault auth and wizard prompt methods
+
+## [0.2.2] - 2026-03-18
+
+### Added
+- Dotfile scanning: gitconfig (name, email, signing key), JFrog CLI servers, Terraform credential hosts
+- `Scanner#scan_dotfiles`, `#scan_gitconfig`, `#scan_jfrog`, `#scan_terraform` methods
+- Onboarding reveal box now displays discovered dotfile configuration
+- Specs for all dotfile scanning and summary display methods
+
+## [0.2.1] - 2026-03-18
+
+### Changed
+- Onboarding replaces credential prompts with LLM provider auto-detection and ping-testing
+- Shows green checkmark or red X with latency for each configured provider
+- Auto-selects default provider or lets user choose if multiple are available
+
+### Added
+- `Background::LlmProbe` for async provider ping-testing during onboarding
+- `WizardPrompt#display_provider_results` and `#select_default_provider` methods
+- Bootsnap and YJIT startup optimizations in `exe/legion-tty`
+
 ## [0.2.0] - 2026-03-18
 
 ### Added

data/exe/legion-tty

@@ -5,9 +5,9 @@ RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
 
 require 'bootsnap'
 Bootsnap.setup(
-  cache_dir:          File.expand_path('~/.legionio/cache/bootsnap'),
-  development_mode:   false,
-  load_path_cache:    true,
+  cache_dir: File.expand_path('~/.legionio/cache/bootsnap'),
+  development_mode: false,
+  load_path_cache: true,
   compile_cache_iseq: true,
   compile_cache_yaml: true
 )

data/lib/legion/tty/background/bootstrap_config.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'fileutils'
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Legion
+  module TTY
+    module Background
+      class BootstrapConfig
+        ENV_KEY = 'LEGIONIO_BOOTSTRAP_CONFIG'
+        SETTINGS_DIR = File.expand_path('~/.legionio/settings')
+
+        def initialize(logger: nil)
+          @log = logger
+        end
+
+        def run_async(queue)
+          Thread.new do
+            result = perform_bootstrap
+            queue.push(result)
+          rescue StandardError => e
+            @log&.log('bootstrap', "ERROR: #{e.class}: #{e.message}")
+            queue.push({ type: :bootstrap_error, error: e.message })
+          end
+        end
+
+        private
+
+        def perform_bootstrap
+          @log&.log('bootstrap', 'checking for bootstrap config')
+          source = ENV.fetch(ENV_KEY, nil)
+          return skip_result unless source && !source.empty?
+
+          @log&.log('bootstrap', "source: #{source}")
+          body = fetch_source(source)
+          config = parse_payload(body)
+          written = write_split_config(config)
+          @log&.log('bootstrap', "wrote #{written.size} config files: #{written.join(', ')}")
+          { type: :bootstrap_complete, data: { files: written, sections: config.keys.map(&:to_s) } }
+        end
+
+        def skip_result
+          @log&.log('bootstrap', "#{ENV_KEY} not set, skipping")
+          { type: :bootstrap_complete, data: nil }
+        end
+
+        def fetch_source(source)
+          if source.match?(%r{\Ahttps?://}i)
+            fetch_http(source)
+          else
+            path = File.expand_path(source)
+            raise "File not found: #{source}" unless File.exist?(path)
+
+            File.read(path)
+          end
+        end
+
+        def fetch_http(url)
+          uri = URI.parse(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == 'https'
+          http.open_timeout = 10
+          http.read_timeout = 10
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+          raise "HTTP #{response.code}: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+          response.body
+        end
+
+        def parse_payload(body)
+          parsed = ::JSON.parse(body, symbolize_names: true)
+          raise 'Config must be a JSON object' unless parsed.is_a?(Hash)
+
+          parsed
+        rescue ::JSON::ParserError
+          decoded = Base64.decode64(body)
+          parsed = ::JSON.parse(decoded, symbolize_names: true)
+          raise 'Config must be a JSON object' unless parsed.is_a?(Hash)
+
+          parsed
+        end
+
+        def write_split_config(config)
+          FileUtils.mkdir_p(SETTINGS_DIR)
+          written = []
+
+          config.each do |key, value|
+            next unless value.is_a?(Hash)
+
+            path = File.join(SETTINGS_DIR, "#{key}.json")
+            content = { key => value }
+
+            if File.exist?(path)
+              existing = ::JSON.parse(File.read(path), symbolize_names: true)
+              content = deep_merge(existing, content)
+            end
+
+            File.write(path, ::JSON.pretty_generate(content))
+            written << "#{key}.json"
+          end
+
+          written
+        end
+
+        def deep_merge(base, overlay)
+          base.merge(overlay) do |_key, old_val, new_val|
+            if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+              deep_merge(old_val, new_val)
+            else
+              new_val
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/background/llm_probe.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Background
+      class LlmProbe
+        def initialize(logger: nil)
+          @log = logger
+        end
+
+        def run_async(queue)
+          Thread.new do
+            result = probe_providers
+            queue.push({ data: result })
+          rescue StandardError => e
+            @log&.log('llm_probe', "error: #{e.message}")
+            queue.push({ data: { providers: [], error: e.message } })
+          end
+        end
+
+        private
+
+        def probe_providers
+          require 'legion/llm'
+          require 'legion/settings'
+          start_llm
+          results = collect_provider_results
+          { providers: results }
+        end
+
+        def start_llm
+          Legion::LLM.start unless Legion::LLM.started?
+        rescue StandardError => e
+          @log&.log('llm_probe', "LLM start failed: #{e.message}")
+        end
+
+        def collect_provider_results
+          providers = Legion::LLM.settings[:providers] || {}
+          providers.filter_map do |name, config|
+            next unless config[:enabled]
+
+            result = ping_provider(name, config)
+            @log&.log('llm_probe', "#{name}: #{result[:status]} (#{result[:latency_ms]}ms)")
+            result
+          end
+        end
+
+        def ping_provider(name, config)
+          model = config[:default_model]
+          start_time = Time.now
+          RubyLLM.chat(model: model, provider: name).ask('Respond with only: pong')
+          latency = ((Time.now - start_time) * 1000).round
+          { name: name, model: model, status: :ok, latency_ms: latency }
+        rescue StandardError => e
+          latency = ((Time.now - start_time) * 1000).round
+          { name: name, model: model, status: :error, latency_ms: latency, error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/background/scanner.rb

@@ -60,7 +60,15 @@ module Legion
 
         def scan_all
           { services: scan_services, repos: scan_git_repos, tools: scan_shell_history,
-            configs: scan_config_files }
+            configs: scan_config_files, dotfiles: scan_dotfiles }
+        end
+
+        def scan_dotfiles
+          {
+            git: scan_gitconfig,
+            jfrog: scan_jfrog,
+            terraform: scan_terraform
+          }
         end
 
         def run_async(queue)
@@ -153,6 +161,49 @@ module Legion
         def extract_command(line)
           line.sub(/^: \d+:\d+;/, '').split.first
         end
+
+        def scan_gitconfig
+          name = `git config --global user.name 2>/dev/null`.strip
+          email = `git config --global user.email 2>/dev/null`.strip
+          signing_key = `git config --global user.signingkey 2>/dev/null`.strip
+          return nil if name.empty? && email.empty?
+
+          result = { name: name.empty? ? nil : name, email: email.empty? ? nil : email }
+          result[:signing_key] = signing_key unless signing_key.empty?
+          result
+        rescue StandardError
+          nil
+        end
+
+        def scan_jfrog
+          config_path = File.expand_path('~/.jfrog/jfrog-cli.conf.v6')
+          return nil unless File.exist?(config_path)
+
+          require 'json'
+          data = ::JSON.parse(File.read(config_path), symbolize_names: true)
+          servers = data[:servers]
+          return nil unless servers.is_a?(Array) && !servers.empty?
+
+          servers.map do |s|
+            { server_id: s[:serverId], url: s[:url], user: s[:user] }
+          end
+        rescue StandardError
+          nil
+        end
+
+        def scan_terraform
+          creds_path = File.expand_path('~/.terraform.d/credentials.tfrc.json')
+          return nil unless File.exist?(creds_path)
+
+          require 'json'
+          data = ::JSON.parse(File.read(creds_path), symbolize_names: true)
+          hosts = data[:credentials]&.keys || []
+          return nil if hosts.empty?
+
+          { hosts: hosts.map(&:to_s) }
+        rescue StandardError
+          nil
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end

data/lib/legion/tty/components/wizard_prompt.rb

@@ -34,6 +34,14 @@ module Legion
           @prompt.mask("Enter API key for #{provider}:")
         end
 
+        def ask_secret(question)
+          @prompt.mask(question)
+        end
+
+        def ask_with_default(question, default)
+          @prompt.ask(question, default: default)
+        end
+
         # rubocop:disable Naming/PredicateMethod
         def confirm(question)
           @prompt.yes?(question)
@@ -43,6 +51,26 @@ module Legion
         def select_from(question, choices)
           @prompt.select(question, choices)
         end
+
+        def display_provider_results(providers)
+          providers.each do |p|
+            icon = p[:status] == :ok ? "\u2705" : "\u274C"
+            latency = "#{p[:latency_ms]}ms"
+            label = "#{icon} #{p[:name]} (#{p[:model]}) \u2014 #{latency}"
+            label += " [#{p[:error]}]" if p[:error]
+            @prompt.say(label)
+          end
+        end
+
+        def select_default_provider(working_providers)
+          return nil if working_providers.empty?
+          return working_providers.first[:name] if working_providers.size == 1
+
+          choices = working_providers.map do |p|
+            { name: "#{p[:name]} (#{p[:model]}, #{p[:latency_ms]}ms)", value: p[:name] }
+          end
+          @prompt.select('Multiple providers available. Choose your default:', choices)
+        end
       end
     end
   end

data/lib/legion/tty/screens/onboarding.rb

@@ -6,6 +6,7 @@ require_relative '../components/wizard_prompt'
 require_relative '../background/scanner'
 require_relative '../background/github_probe'
 require_relative '../background/kerberos_probe'
+require_relative '../background/bootstrap_config'
 require_relative '../boot_logger'
 require_relative '../theme'
 
@@ -25,11 +26,16 @@ module Legion
           @github_queue = Queue.new
           @github_quick_queue = Queue.new
           @kerberos_queue = Queue.new
+          @llm_queue = Queue.new
+          @bootstrap_queue = Queue.new
           @kerberos_identity = nil
           @github_quick = nil
+          @vault_results = nil
+          @bootstrap_data = nil
           @log = BootLogger.new
         end
 
+        # rubocop:disable Metrics/AbcSize
         def activate
           @log.log('onboarding', 'activate started')
           start_background_threads
@@ -37,11 +43,16 @@ module Legion
           run_intro
           config = run_wizard
           @log.log('wizard', "name=#{config[:name]} provider=#{config[:provider]}")
+          collect_bootstrap_result
+          run_vault_auth
           scan_data, github_data = collect_background_results
+          run_cache_awakening(scan_data)
+          run_gaia_awakening
           run_reveal(name: config[:name], scan_data: scan_data, github_data: github_data)
           @log.log('onboarding', 'activate complete')
           build_onboarding_result(config, scan_data, github_data)
         end
+        # rubocop:enable Metrics/AbcSize
 
         # rubocop:disable Metrics/AbcSize
         def run_rain
@@ -92,13 +103,34 @@ module Legion
           typed_output("  Nice to meet you, #{name}.")
           @output.puts
           sleep 1
-          typed_output("Let's get you connected.")
+          providers = detect_providers
+          default = select_provider_default(providers)
+          @output.puts
+          { name: name, provider: default, providers: providers }
+        end
+
+        def detect_providers
+          typed_output('Detecting AI providers...')
           @output.puts
           @output.puts
-          provider = @wizard.select_provider
-          sleep 0.5
-          api_key = @wizard.ask_api_key(provider: provider)
-          { name: name, provider: provider, api_key: api_key }
+          llm_data = drain_with_timeout(@llm_queue, timeout: 15)
+          providers = llm_data&.dig(:data, :providers) || []
+          @wizard.display_provider_results(providers)
+          @output.puts
+          providers
+        end
+
+        def select_provider_default(providers)
+          working = providers.select { |p| p[:status] == :ok }
+          if working.any?
+            default = @wizard.select_default_provider(working)
+            sleep 0.5
+            typed_output("Connected. Let's chat.")
+            default
+          else
+            typed_output('No AI providers detected. Configure one in ~/.legionio/settings/llm.json')
+            nil
+          end
         end
 
         def start_background_threads
@@ -109,7 +141,81 @@ module Legion
           @scanner.run_async(@scan_queue)
           @kerberos_probe.run_async(@kerberos_queue)
           @github_probe.run_quick_async(@github_quick_queue)
+          require_relative '../background/llm_probe'
+          @llm_probe = Background::LlmProbe.new(logger: @log)
+          @llm_probe.run_async(@llm_queue)
+          @bootstrap_probe = Background::BootstrapConfig.new(logger: @log)
+          @bootstrap_probe.run_async(@bootstrap_queue)
+        end
+
+        def run_cache_awakening(scan_data)
+          services = scan_data.is_a?(Hash) ? scan_data[:services] : nil
+          return unless services.is_a?(Hash)
+
+          if services.dig(:memcached, :running) || services.dig(:redis, :running)
+            typed_output('... extending neural pathways...')
+            sleep 0.8
+            typed_output('Additional memory online.')
+          else
+            run_cache_offer
+          end
+          @output.puts
+        end
+
+        def run_cache_offer
+          typed_output('No extended memory detected.')
+          sleep 0.8
+          @output.puts
+          return unless @wizard.confirm('Shall I activate a memory cache?')
+
+          binary = detect_cache_binary
+          if binary
+            run_cache_start(binary)
+          else
+            typed_output('No cache service found. Install with: brew install memcached')
+          end
+        end
+
+        def run_cache_start(binary)
+          started = start_cache_service(binary.to_s)
+          if started
+            typed_output('Memory cache activated. Neural capacity expanded.')
+          else
+            typed_output("No cache service found. Install with: brew install #{binary}")
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def run_gaia_awakening
+          typed_output('Scanning for active cognition threads...')
+          sleep 1.2
+          @output.puts
+
+          if legionio_running?
+            typed_output('GAIA is awake.')
+            sleep 0.5
+            typed_output('Heuristic mesh: nominal.')
+            sleep 0.8
+            typed_output('Cognitive threads synchronized.')
+          else
+            typed_output('GAIA is dormant.')
+            sleep 1
+            @output.puts
+            if @wizard.confirm('Shall I wake her?')
+              started = start_legionio_daemon
+              if started
+                typed_output('... initializing cognitive substrate...')
+                sleep 1
+                typed_output('GAIA online. All systems nominal.')
+              else
+                typed_output("Could not start daemon. Run 'legionio start' manually.")
+              end
+            end
+          end
+
+          @output.puts
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def collect_background_results
           @log.log('collect', 'waiting for scanner results (10s timeout)')
@@ -145,16 +251,104 @@ module Legion
           sleep 1
         end
 
+        # rubocop:disable Metrics/AbcSize
         def build_summary(name:, scan_data:, github_data:)
           lines = ["Hello, #{name}!", '', "Here's what I found:"]
+          lines.concat(bootstrap_summary_lines)
           lines.concat(identity_summary_lines)
           lines.concat(scan_summary_lines(scan_data))
+          lines.concat(dotfiles_summary_lines(scan_data))
           lines.concat(github_summary_lines(github_data))
+          lines.concat(vault_summary_lines)
+          lines.concat(cache_summary_lines(scan_data))
+          lines.concat(gaia_summary_lines)
           lines.join("\n")
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def collect_bootstrap_result
+          result = drain_with_timeout(@bootstrap_queue, timeout: 5)
+          @bootstrap_data = result&.dig(:data)
+          return unless @bootstrap_data
+
+          files = @bootstrap_data[:files] || []
+          @log.log('bootstrap', "imported #{files.size} config files: #{files.join(', ')}")
+          typed_output('Configuration loaded.')
+          @output.puts
+        end
+
+        def run_vault_auth
+          return unless vault_clusters_configured?
+
+          count = vault_cluster_count
+          @output.puts
+          typed_output("I found #{count} Vault cluster#{'s' if count != 1}.")
+          @output.puts
+          return unless @wizard.confirm('Connect now?')
+
+          run_vault_auth_credentials
+        end
+
+        def run_vault_auth_credentials
+          username = @wizard.ask_with_default('Username:', default_vault_username)
+          password = @wizard.ask_secret('Password:')
+          return if password.nil? || password.empty?
+
+          @output.puts
+          typed_output('Authenticating...')
+          @output.puts
+
+          @vault_results = perform_vault_auth(username, password)
+          display_vault_results(@vault_results)
+        end
+
+        def vault_clusters_configured?
+          return false unless defined?(Legion::Settings)
+
+          clusters = Legion::Settings.dig(:crypt, :vault, :clusters)
+          clusters.is_a?(Hash) && clusters.any?
+        rescue StandardError
+          false
+        end
+
+        def vault_cluster_count
+          Legion::Settings.dig(:crypt, :vault, :clusters)&.size || 0
+        rescue StandardError
+          0
+        end
+
+        def default_vault_username
+          if @kerberos_identity&.dig(:samaccountname)
+            @kerberos_identity[:samaccountname]
+          else
+            ENV.fetch('USER', 'unknown')
+          end
+        end
+
+        def perform_vault_auth(username, password)
+          return {} unless defined?(Legion::Crypt) && Legion::Crypt.respond_to?(:ldap_login_all)
+
+          Legion::Crypt.ldap_login_all(username: username, password: password)
+        rescue StandardError => e
+          @log.log('vault', "LDAP auth failed: #{e.message}")
+          {}
+        end
+
+        def display_vault_results(results)
+          results.each do |name, result|
+            if result[:error]
+              @output.puts "  #{Theme.c(:error, 'X')} #{name}: #{result[:error]}"
+            else
+              policies = result[:policies]&.size || 0
+              @output.puts "  #{Theme.c(:success, 'ok')} #{name}: connected (#{policies} policies)"
+            end
+          end
+          @output.puts
+          sleep 1
+        end
+
         def build_onboarding_result(config, scan_data, github_data)
           {
             **config,
@@ -282,6 +476,85 @@ module Legion
           ['', "Running services: #{running.join(', ')}"]
         end
 
+        def dotfiles_summary_lines(scan_data)
+          return [] unless scan_data.is_a?(Hash)
+
+          dotfiles = scan_data[:dotfiles]
+          return [] unless dotfiles.is_a?(Hash)
+
+          lines = []
+          lines.concat(git_summary_lines(dotfiles[:git]))
+          lines.concat(jfrog_summary_lines(dotfiles[:jfrog]))
+          lines.concat(terraform_summary_lines(dotfiles[:terraform]))
+          lines
+        end
+
+        def git_summary_lines(git)
+          return [] unless git.is_a?(Hash)
+
+          lines = ['', "Git: #{git[:name]} <#{git[:email]}>"]
+          lines << "  Signing key: #{git[:signing_key]}" if git[:signing_key]
+          lines
+        end
+
+        def jfrog_summary_lines(jfrog)
+          return [] unless jfrog.is_a?(Array) && !jfrog.empty?
+
+          lines = ['', 'JFrog Artifactory:']
+          jfrog.each { |s| lines << "  #{s[:server_id]}: #{s[:url]} (#{s[:user]})" }
+          lines
+        end
+
+        def vault_summary_lines
+          return [] unless @vault_results.is_a?(Hash) && @vault_results.any?
+
+          lines = ['', 'Vault:']
+          @vault_results.each do |name, result|
+            lines << if result[:error]
+                       "  #{name}: failed (#{result[:error]})"
+                     else
+                       "  #{name}: connected"
+                     end
+          end
+          lines
+        end
+
+        def cache_summary_lines(scan_data)
+          services = scan_data.is_a?(Hash) ? scan_data[:services] : nil
+          return [] unless services.is_a?(Hash)
+
+          if services.dig(:memcached, :running)
+            ['', 'Memory: memcached online']
+          elsif services.dig(:redis, :running)
+            ['', 'Memory: redis online']
+          else
+            ['', 'Memory: no cache service running']
+          end
+        end
+
+        def bootstrap_summary_lines
+          return [] unless @bootstrap_data.is_a?(Hash)
+
+          sections = @bootstrap_data[:sections] || []
+          return [] if sections.empty?
+
+          ['', "Bootstrap config: #{sections.join(', ')}"]
+        end
+
+        def gaia_summary_lines
+          if legionio_running?
+            ['', 'GAIA: online']
+          else
+            ['', 'GAIA: dormant']
+          end
+        end
+
+        def terraform_summary_lines(dotfiles_tf)
+          return [] unless dotfiles_tf.is_a?(Hash) && dotfiles_tf[:hosts]&.any?
+
+          ['', "Terraform: #{dotfiles_tf[:hosts].join(', ')}"]
+        end
+
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
         def github_summary_lines(github_data)
           return [] unless github_data.is_a?(Hash)
@@ -443,6 +716,66 @@ module Legion
           nil
         end
 
+        def detect_cache_binary
+          if system('which memcached > /dev/null 2>&1')
+            :memcached
+          elsif system('which redis-server > /dev/null 2>&1')
+            :redis
+          end
+        end
+
+        def start_cache_service(service_name)
+          @log.log('cache', "starting #{service_name} via brew services")
+          result = system("brew services start #{service_name} > /dev/null 2>&1")
+          @log.log('cache', "brew services start #{service_name}: #{result ? 'ok' : 'failed'}")
+          result
+        rescue StandardError => e
+          @log.log('cache', "failed to start #{service_name}: #{e.message}")
+          false
+        end
+
+        def legionio_running?
+          pid_paths = [
+            File.expand_path('~/.legionio/legion.pid'),
+            '/tmp/legionio.pid'
+          ]
+          pid_paths.each do |path|
+            next unless File.exist?(path)
+
+            pid = File.read(path).strip.to_i
+            next unless pid.positive?
+
+            begin
+              ::Process.kill(0, pid)
+              return true
+            rescue Errno::ESRCH
+              next
+            rescue Errno::EPERM
+              return true
+            end
+          end
+          system('pgrep -x legionio > /dev/null 2>&1')
+        rescue StandardError
+          false
+        end
+
+        def start_legionio_daemon
+          @log.log('gaia', 'attempting to start legionio daemon')
+          if system('brew services start legionio > /dev/null 2>&1')
+            @log.log('gaia', 'started via brew services')
+            true
+          elsif system('legionio start -d > /dev/null 2>&1')
+            @log.log('gaia', 'started via legionio start -d')
+            true
+          else
+            @log.log('gaia', 'failed to start daemon')
+            false
+          end
+        rescue StandardError => e
+          @log.log('gaia', "start failed: #{e.message}")
+          false
+        end
+
         def terminal_width
           require 'tty-screen'
           ::TTY::Screen.width

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.2.0'
+    VERSION = '0.2.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - Esity
@@ -195,8 +195,10 @@ files:
 - exe/legion-tty
 - lib/legion/tty.rb
 - lib/legion/tty/app.rb
+- lib/legion/tty/background/bootstrap_config.rb
 - lib/legion/tty/background/github_probe.rb
 - lib/legion/tty/background/kerberos_probe.rb
+- lib/legion/tty/background/llm_probe.rb
 - lib/legion/tty/background/scanner.rb
 - lib/legion/tty/boot_logger.rb
 - lib/legion/tty/components/digital_rain.rb