legion-tty 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e5ec362f89174ce0ccc182a50343da7a6ce2846f3c01ad51ad14afe8a7f80f8
-  data.tar.gz: 763d695f1c7a2e8c13e3a518b36d2e90ae25713954a2127f5ed71869eaa31908
+  metadata.gz: 93f9cd78860072bfa0df27f33574552a7d5ac749fbb9440f61017ed76f7f9f4d
+  data.tar.gz: c590bb6fb1cbe8639b5df4e46e0aa255f5d23f01499c8d2b1137ad86700412b7
 SHA512:
-  metadata.gz: 4cde6c72b3a66dd7b5daffce9c3407c0d82275a41bb1ed564579ccd013d31bd2f42f4e0366426446adf19f382d5f4911de6cc04622c86fd2e7090663ba1b7177
-  data.tar.gz: e4350ae0a6145f62758118c141f809de74d90ba5db873cbae1bd499c0c6b958325fa2196f91edd3df7aa3ddeb933f0fc818e3b7a372fab9ff8feb157f68ac680
+  metadata.gz: 8880c1013b5c36a3d9a7d378280b6a1212ba82f527a37dd7f5f81b5b0fc591435ea10fec4a565b5e95a714be1b6340b587214ce9ccde08ee1dfbc63572e0d2f9
+  data.tar.gz: d99de6e491d811a3e891833760c4f25fe45c4034494bd200322b41145fc39a16929b8ea3b5295c2044cc1e123e45f30022f310ca97aaf1643f842696a424db77

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.4.3] - 2026-03-19
+
+### Added
+- Daemon-first chat routing: chat screen routes through LegionIO daemon when available
+- `send_via_daemon` and `send_via_direct` methods with automatic fallback
+- `daemon_available?` guard for `Legion::LLM::DaemonClient` presence
+
+## [0.4.2] - 2026-03-19
+
+### Added
+- Multi-provider model switching: `/model <provider>` creates new Legion::LLM.chat instance
+- Model picker integration: `open_model_picker` for interactive provider/model selection
+- ToolPanel wiring in MessageStream: `add_tool_call`, `update_tool_call` methods
+- Tool call rendering in chat messages (`:tool` role with panel display)
+
+### Fixed
+- Flaky table_view_spec: added explicit `require 'tty-table'` to prevent test ordering failures
+
 ## [0.4.1] - 2026-03-19
 
 ### Added

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

@@ -41,11 +41,17 @@ module Legion
           @completions.select { |c| c.start_with?(partial) }.sort
         end
 
+        def history
+          return [] unless @reader.respond_to?(:history)
+
+          @reader.history.to_a
+        end
+
         private
 
         def build_default_reader
           require 'tty-reader'
-          reader = ::TTY::Reader.new
+          reader = ::TTY::Reader.new(history_cycle: true)
           register_tab_completion(reader)
           reader
         rescue LoadError

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

@@ -29,6 +29,21 @@ module Legion
           @messages.last[:tool_panels] << panel
         end
 
+        def add_tool_call(name:, args: {}, status: :running)
+          require_relative 'tool_panel'
+          panel = ToolPanel.new(name: name, args: args, status: status)
+          @messages << { role: :tool, content: panel, tool_panel: true }
+        end
+
+        def update_tool_call(name:, status:, duration: nil, result: nil, error: nil)
+          tool_msg = @messages.reverse.find do |m|
+            m[:tool_panel] && m[:content].is_a?(ToolPanel) && m[:content].instance_variable_get(:@name) == name
+          end
+          return unless tool_msg
+
+          apply_tool_panel_update(tool_msg[:content], status: status, duration: duration, result: result, error: error)
+        end
+
         def scroll_up(lines = 1)
           @scroll_offset += lines
         end
@@ -60,6 +75,7 @@ module Legion
           when :user then user_lines(msg)
           when :assistant then assistant_lines(msg, width)
           when :system then system_lines(msg)
+          when :tool then tool_call_lines(msg, width)
           else []
           end
         end
@@ -85,9 +101,22 @@ module Legion
           msg[:content].split("\n").map { |l| "  #{Theme.c(:muted, l)}" }
         end
 
+        def tool_call_lines(msg, width)
+          return [] unless msg[:tool_panel] && msg[:content].respond_to?(:render)
+
+          msg[:content].render(width: width).split("\n")
+        end
+
         def panel_lines(msg, width)
           msg[:tool_panels].flat_map { |panel| panel.render(width: width).split("\n") }
         end
+
+        def apply_tool_panel_update(panel, status:, duration:, result:, error:)
+          panel.instance_variable_set(:@status, status)
+          panel.instance_variable_set(:@duration, duration) if duration
+          panel.instance_variable_set(:@result, result) if result
+          panel.instance_variable_set(:@error, error) if error
+        end
       end
     end
   end

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

@@ -13,7 +13,7 @@ module Legion
       # rubocop:disable Metrics/ClassLength
       class Chat < Base
         SLASH_COMMANDS = %w[/help /quit /clear /model /session /cost /export /tools /dashboard /hotkeys /save /load
-                            /sessions /system /delete /plan /palette /extensions /config].freeze
+                            /sessions /system /delete /plan /palette /extensions /config /theme].freeze
 
         attr_reader :message_stream, :status_bar
 
@@ -92,20 +92,16 @@ module Legion
         end
 
         def send_to_llm(message)
-          unless @llm_chat
+          unless @llm_chat || daemon_available?
             @message_stream.append_streaming('LLM not configured. Use /help for commands.')
             return
           end
 
-          @status_bar.update(thinking: true)
-          render_screen
-          response = @llm_chat.ask(message) do |chunk|
-            @status_bar.update(thinking: false)
-            @message_stream.append_streaming(chunk.content) if chunk.content
-            render_screen
+          if daemon_available?
+            send_via_daemon(message)
+          else
+            send_via_direct(message)
           end
-          @status_bar.update(thinking: false)
-          track_response_tokens(response)
         rescue StandardError => e
           @status_bar.update(thinking: false)
           @message_stream.append_streaming("\n[Error: #{e.message}]")
@@ -142,6 +138,40 @@ module Legion
           @llm_chat.with_instructions(prompt) if @llm_chat.respond_to?(:with_instructions)
         end
 
+        def send_via_daemon(message)
+          result = Legion::LLM.ask(message: message)
+
+          case result&.dig(:status)
+          when :done
+            @message_stream.append_streaming(result[:response])
+          when :error
+            err = result.dig(:error, :message) || 'Unknown error'
+            @message_stream.append_streaming("\n[Daemon error: #{err}]")
+          else
+            send_via_direct(message)
+          end
+        rescue StandardError
+          send_via_direct(message)
+        end
+
+        def send_via_direct(message)
+          return unless @llm_chat
+
+          @status_bar.update(thinking: true)
+          render_screen
+          response = @llm_chat.ask(message) do |chunk|
+            @status_bar.update(thinking: false)
+            @message_stream.append_streaming(chunk.content) if chunk.content
+            render_screen
+          end
+          @status_bar.update(thinking: false)
+          track_response_tokens(response)
+        end
+
+        def daemon_available?
+          !!(defined?(Legion::LLM::DaemonClient) && Legion::LLM::DaemonClient.available?)
+        end
+
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def build_system_prompt(cfg)
           lines = ['You are Legion, an async cognition engine and AI assistant.']
@@ -245,6 +275,7 @@ module Legion
           when '/palette' then handle_palette
           when '/extensions' then handle_extensions_screen
           when '/config' then handle_config_screen
+          when '/theme' then handle_theme(input)
           else :handled
           end
         end
@@ -255,7 +286,8 @@ module Legion
             role: :system,
             content: "Commands:\n  /help /quit /clear /model <name> /session <name> /cost\n  " \
                      "/export [md|json] /tools /dashboard /hotkeys /save /load /sessions\n  " \
-                     "/system <prompt> /delete <session> /plan /palette /extensions /config\n\n" \
+                     "/system <prompt> /delete <session> /plan /palette /extensions /config\n  " \
+                     "/theme [name] -- switch color theme (purple, green, blue, amber)\n\n" \
                      'Hotkeys: Ctrl+D=dashboard  Ctrl+K=palette  Ctrl+S=sessions  Esc=back'
           )
           :handled
@@ -282,16 +314,50 @@ module Legion
             return
           end
 
-          if @llm_chat.respond_to?(:with_model)
+          apply_model_switch(name)
+        rescue StandardError => e
+          @message_stream.add_message(role: :system, content: "Failed to switch model: #{e.message}")
+        end
+
+        def apply_model_switch(name)
+          new_chat = try_provider_switch(name)
+          if new_chat
+            @llm_chat = new_chat
+            @status_bar.update(model: name)
+            @token_tracker.update_model(name)
+            @message_stream.add_message(role: :system, content: "Switched to provider: #{name}")
+          elsif @llm_chat.respond_to?(:with_model)
             @llm_chat.with_model(name)
             @status_bar.update(model: name)
+            @token_tracker.update_model(name)
             @message_stream.add_message(role: :system, content: "Model switched to: #{name}")
           else
             @status_bar.update(model: name)
             @message_stream.add_message(role: :system, content: "Model set to: #{name}")
           end
-        rescue StandardError => e
-          @message_stream.add_message(role: :system, content: "Failed to switch model: #{e.message}")
+        end
+
+        def try_provider_switch(name)
+          return nil unless defined?(Legion::LLM)
+
+          providers = Legion::LLM.settings[:providers]
+          return nil unless providers.is_a?(Hash) && providers.key?(name.to_sym)
+
+          Legion::LLM.chat(provider: name)
+        rescue StandardError
+          nil
+        end
+
+        def open_model_picker
+          require_relative '../components/model_picker'
+          picker = Components::ModelPicker.new(
+            current_provider: safe_config[:provider],
+            current_model: @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : nil
+          )
+          selection = picker.select_with_prompt(output: @output)
+          return unless selection
+
+          switch_model(selection[:provider])
         end
 
         def show_current_model
@@ -506,6 +572,23 @@ module Legion
           :handled
         end
 
+        def handle_theme(input)
+          name = input.split(nil, 2)[1]
+          if name
+            if Theme.switch(name)
+              @message_stream.add_message(role: :system, content: "Theme switched to: #{name}")
+            else
+              available = Theme.available_themes.join(', ')
+              @message_stream.add_message(role: :system, content: "Unknown theme '#{name}'. Available: #{available}")
+            end
+          else
+            current = Theme.current_theme
+            available = Theme.available_themes.join(', ')
+            @message_stream.add_message(role: :system, content: "Current theme: #{current}\nAvailable: #{available}")
+          end
+          :handled
+        end
+
         def detect_provider
           cfg = safe_config
           provider = cfg[:provider].to_s.downcase

data/lib/legion/tty/theme.rb

@@ -2,44 +2,100 @@
 
 module Legion
   module TTY
+    # rubocop:disable Metrics/ModuleLength
     module Theme
       # rubocop:disable Naming/VariableNumber
-      PALETTE = {
-        purple_1: [30, 27, 46],
-        purple_2: [41, 37, 63],
-        purple_3: [52, 47, 80],
-        purple_4: [63, 57, 97],
-        purple_5: [74, 67, 114],
-        purple_6: [85, 77, 131],
-        purple_7: [96, 87, 148],
-        purple_8: [107, 97, 165],
-        purple_9: [118, 107, 182],
-        purple_10: [129, 119, 199],
-        purple_11: [140, 131, 210],
-        purple_12: [157, 148, 221],
-        purple_13: [174, 167, 230],
-        purple_14: [191, 186, 239],
-        purple_15: [208, 205, 245],
-        purple_16: [225, 224, 250],
-        purple_17: [242, 243, 255]
+      THEMES = {
+        purple: {
+          palette: {
+            shade_1: [30, 27, 46], shade_2: [41, 37, 63], shade_3: [52, 47, 80],
+            shade_4: [63, 57, 97], shade_5: [74, 67, 114], shade_6: [85, 77, 131],
+            shade_7: [96, 87, 148], shade_8: [107, 97, 165], shade_9: [118, 107, 182],
+            shade_10: [129, 119, 199], shade_11: [140, 131, 210], shade_12: [157, 148, 221],
+            shade_13: [174, 167, 230], shade_14: [191, 186, 239], shade_15: [208, 205, 245],
+            shade_16: [225, 224, 250], shade_17: [242, 243, 255]
+          },
+          semantic: {
+            primary: :shade_9, secondary: :shade_6, accent: :shade_12,
+            success: [0, 200, 83], warning: [255, 191, 0], error: [255, 69, 58],
+            info: :shade_7, surface: :shade_1, muted: :shade_4,
+            rain: :shade_11, rain_fade: :shade_3
+          }
+        },
+        green: {
+          palette: {
+            shade_1: [15, 30, 15], shade_2: [20, 45, 20], shade_3: [25, 60, 25],
+            shade_4: [30, 75, 30], shade_5: [35, 90, 35], shade_6: [40, 110, 40],
+            shade_7: [50, 130, 50], shade_8: [60, 150, 60], shade_9: [75, 170, 75],
+            shade_10: [90, 190, 90], shade_11: [110, 210, 110], shade_12: [140, 225, 140],
+            shade_13: [170, 235, 170], shade_14: [195, 242, 195], shade_15: [215, 248, 215],
+            shade_16: [230, 252, 230], shade_17: [245, 255, 245]
+          },
+          semantic: {
+            primary: :shade_9, secondary: :shade_6, accent: :shade_12,
+            success: [0, 200, 83], warning: [255, 191, 0], error: [255, 69, 58],
+            info: :shade_7, surface: :shade_1, muted: :shade_4,
+            rain: :shade_11, rain_fade: :shade_3
+          }
+        },
+        blue: {
+          palette: {
+            shade_1: [15, 20, 40], shade_2: [20, 30, 60], shade_3: [25, 40, 80],
+            shade_4: [30, 50, 100], shade_5: [40, 65, 120], shade_6: [50, 80, 140],
+            shade_7: [65, 100, 160], shade_8: [80, 120, 180], shade_9: [100, 140, 200],
+            shade_10: [120, 160, 215], shade_11: [145, 185, 225], shade_12: [170, 205, 235],
+            shade_13: [195, 220, 242], shade_14: [210, 230, 248], shade_15: [225, 240, 252],
+            shade_16: [238, 248, 255], shade_17: [248, 252, 255]
+          },
+          semantic: {
+            primary: :shade_9, secondary: :shade_6, accent: :shade_12,
+            success: [0, 200, 83], warning: [255, 191, 0], error: [255, 69, 58],
+            info: :shade_7, surface: :shade_1, muted: :shade_4,
+            rain: :shade_11, rain_fade: :shade_3
+          }
+        },
+        amber: {
+          palette: {
+            shade_1: [35, 25, 10], shade_2: [50, 35, 15], shade_3: [65, 45, 20],
+            shade_4: [80, 55, 25], shade_5: [100, 70, 30], shade_6: [120, 85, 35],
+            shade_7: [140, 100, 40], shade_8: [165, 120, 50], shade_9: [190, 140, 60],
+            shade_10: [210, 160, 70], shade_11: [225, 180, 85], shade_12: [235, 200, 110],
+            shade_13: [242, 215, 140], shade_14: [248, 230, 170], shade_15: [252, 240, 200],
+            shade_16: [255, 248, 225], shade_17: [255, 252, 245]
+          },
+          semantic: {
+            primary: :shade_9, secondary: :shade_6, accent: :shade_12,
+            success: [0, 200, 83], warning: [255, 191, 0], error: [255, 69, 58],
+            info: :shade_7, surface: :shade_1, muted: :shade_4,
+            rain: :shade_11, rain_fade: :shade_3
+          }
+        }
       }.freeze
 
-      SEMANTIC = {
-        primary: :purple_9,
-        secondary: :purple_6,
-        accent: :purple_12,
-        success: [0, 200, 83],
-        warning: [255, 191, 0],
-        error: [255, 69, 58],
-        info: :purple_7,
-        surface: :purple_1,
-        muted: :purple_4,
-        rain: :purple_11,
-        rain_fade: :purple_3
-      }.freeze
+      # Legacy aliases for backward compatibility
+      PALETTE = THEMES[:purple][:palette].transform_keys { |k| k.to_s.sub('shade_', 'purple_').to_sym }.freeze
+      SEMANTIC = THEMES[:purple][:semantic].freeze
       # rubocop:enable Naming/VariableNumber
 
       class << self
+        def current_theme
+          @current_theme || :purple
+        end
+
+        # rubocop:disable Naming/PredicateMethod
+        def switch(name)
+          name = name.to_sym
+          return false unless THEMES.key?(name)
+
+          @current_theme = name
+          true
+        end
+        # rubocop:enable Naming/PredicateMethod
+
+        def available_themes
+          THEMES.keys
+        end
+
         def c(name, text)
           rgb = resolve_rgb(name)
           return text unless rgb
@@ -47,17 +103,28 @@ module Legion
           "\e[38;2;#{rgb[0]};#{rgb[1]};#{rgb[2]}m#{text}\e[0m"
         end
 
+        def reset_theme
+          @current_theme = :purple
+        end
+
         private
 
         def resolve_rgb(name)
-          if PALETTE.key?(name)
+          theme = THEMES[current_theme]
+          palette = theme[:palette]
+          semantic = theme[:semantic]
+
+          if palette.key?(name)
+            palette[name]
+          elsif semantic.key?(name)
+            ref = semantic[name]
+            ref.is_a?(Symbol) ? palette[ref] : ref
+          elsif PALETTE.key?(name)
             PALETTE[name]
-          elsif SEMANTIC.key?(name)
-            ref = SEMANTIC[name]
-            ref.is_a?(Symbol) ? PALETTE[ref] : ref
           end
         end
       end
     end
+    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.1'
+    VERSION = '0.4.3'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors:
 - Esity