legion-tty 0.4.11 → 0.4.13

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        # rubocop:disable Metrics/ModuleLength
+        module MessageCommands
+          private
+
+          # rubocop:disable Metrics/AbcSize
+          def handle_compact(input)
+            keep = (input.split(nil, 2)[1] || '5').to_i.clamp(1, 50)
+            msgs = @message_stream.messages
+            if msgs.size <= keep * 2
+              @message_stream.add_message(role: :system, content: 'Conversation is already compact.')
+              return :handled
+            end
+
+            system_msgs = msgs.select { |m| m[:role] == :system }
+            recent = msgs.reject { |m| m[:role] == :system }.last(keep * 2)
+            removed_count = msgs.size - system_msgs.size - recent.size
+            @message_stream.messages.replace(system_msgs + recent)
+            @message_stream.add_message(
+              role: :system,
+              content: "Compacted: removed #{removed_count} older messages, kept #{recent.size} recent."
+            )
+            :handled
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def handle_copy(_input)
+            last_assistant = @message_stream.messages.reverse.find { |m| m[:role] == :assistant }
+            unless last_assistant
+              @message_stream.add_message(role: :system, content: 'No assistant message to copy.')
+              return :handled
+            end
+
+            content = last_assistant[:content].to_s
+            copy_to_clipboard(content)
+            @message_stream.add_message(
+              role: :system,
+              content: "Copied #{content.length} characters to clipboard."
+            )
+            :handled
+          end
+
+          def handle_diff(_input)
+            if @loaded_message_count.nil?
+              @message_stream.add_message(role: :system, content: 'No session was loaded. Nothing to diff against.')
+              return :handled
+            end
+
+            new_count = @message_stream.messages.size - @loaded_message_count
+            if new_count <= 0
+              @message_stream.add_message(role: :system, content: 'No new messages since session was loaded.')
+            else
+              new_msgs = @message_stream.messages.last(new_count)
+              lines = new_msgs.map { |m| "  + [#{m[:role]}] #{truncate_text(m[:content].to_s, 60)}" }
+              @message_stream.add_message(
+                role: :system,
+                content: "#{new_count} new message(s) since load:\n#{lines.join("\n")}"
+              )
+            end
+            :handled
+          end
+
+          def handle_search(input)
+            query = input.split(nil, 2)[1]
+            unless query
+              @message_stream.add_message(role: :system, content: 'Usage: /search <text>')
+              return :handled
+            end
+
+            results = search_messages(query)
+            if results.empty?
+              @message_stream.add_message(role: :system, content: "No messages matching '#{query}'.")
+            else
+              lines = results.map { |r| "  [#{r[:role]}] #{truncate_text(r[:content], 80)}" }
+              @message_stream.add_message(
+                role: :system,
+                content: "Found #{results.size} message(s) matching '#{query}':\n#{lines.join("\n")}"
+              )
+            end
+            :handled
+          end
+
+          def handle_grep(input)
+            pattern_str = input.split(nil, 2)[1]
+            unless pattern_str
+              @message_stream.add_message(role: :system, content: 'Usage: /grep <regex>')
+              return :handled
+            end
+
+            results = grep_messages(pattern_str)
+            display_grep_results(results, pattern_str)
+            :handled
+          rescue RegexpError => e
+            @message_stream.add_message(role: :system, content: "Invalid regex: #{e.message}")
+            :handled
+          end
+
+          def grep_messages(pattern_str)
+            regex = Regexp.new(pattern_str, Regexp::IGNORECASE)
+            @message_stream.messages.select do |msg|
+              msg[:content].is_a?(::String) && regex.match?(msg[:content])
+            end
+          end
+
+          def display_grep_results(results, pattern_str)
+            if results.empty?
+              @message_stream.add_message(role: :system, content: "No messages matching /#{pattern_str}/.")
+            else
+              lines = results.map { |r| "  [#{r[:role]}] #{truncate_text(r[:content], 80)}" }
+              @message_stream.add_message(
+                role: :system,
+                content: "Found #{results.size} message(s) matching /#{pattern_str}/:\n#{lines.join("\n")}"
+              )
+            end
+          end
+
+          def handle_undo
+            msgs = @message_stream.messages
+            last_user_idx = msgs.rindex { |m| m[:role] == :user }
+            unless last_user_idx
+              @message_stream.add_message(role: :system, content: 'Nothing to undo.')
+              return :handled
+            end
+
+            msgs.slice!(last_user_idx..)
+            :handled
+          end
+
+          def handle_pin(input)
+            idx_str = input.split(nil, 2)[1]
+            msg = if idx_str
+                    @message_stream.messages[idx_str.to_i]
+                  else
+                    @message_stream.messages.reverse.find { |m| m[:role] == :assistant }
+                  end
+            unless msg
+              @message_stream.add_message(role: :system, content: 'No message to pin.')
+              return :handled
+            end
+
+            @pinned_messages << msg
+            preview = truncate_text(msg[:content].to_s, 60)
+            @message_stream.add_message(role: :system, content: "Pinned: #{preview}")
+            :handled
+          end
+
+          def handle_pins
+            if @pinned_messages.empty?
+              @message_stream.add_message(role: :system, content: 'No pinned messages.')
+            else
+              lines = @pinned_messages.each_with_index.map do |msg, i|
+                "  #{i + 1}. [#{msg[:role]}] #{truncate_text(msg[:content].to_s, 70)}"
+              end
+              @message_stream.add_message(role: :system,
+                                          content: "Pinned messages (#{@pinned_messages.size}):\n#{lines.join("\n")}")
+            end
+            :handled
+          end
+
+          def search_messages(query)
+            pattern = query.downcase
+            @message_stream.messages.select do |msg|
+              msg[:content].is_a?(::String) && msg[:content].downcase.include?(pattern)
+            end
+          end
+
+          def truncate_text(text, max_length)
+            return text if text.length <= max_length
+
+            "#{text[0...max_length]}..."
+          end
+
+          def copy_to_clipboard(text)
+            IO.popen('pbcopy', 'w') { |io| io.write(text) }
+          rescue Errno::ENOENT
+            begin
+              IO.popen('xclip -selection clipboard', 'w') { |io| io.write(text) }
+            rescue Errno::ENOENT
+              nil
+            end
+          end
+        end
+        # rubocop:enable Metrics/ModuleLength
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        module ModelCommands
+          private
+
+          def handle_model(input)
+            name = input.split(nil, 2)[1]
+            if name
+              switch_model(name)
+            else
+              show_current_model
+            end
+            :handled
+          end
+
+          def switch_model(name)
+            unless @llm_chat
+              @message_stream.add_message(role: :system, content: 'No active LLM session.')
+              return
+            end
+
+            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
+          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
+            model = @llm_chat.respond_to?(:model) ? @llm_chat.model : nil
+            provider = safe_config[:provider] || 'unknown'
+            info = model ? "#{model} (#{provider})" : provider
+            @message_stream.add_message(role: :system, content: "Current model: #{info}")
+          end
+
+          def handle_system(input)
+            text = input.split(nil, 2)[1]
+            if text
+              if @llm_chat.respond_to?(:with_instructions)
+                @llm_chat.with_instructions(text)
+                @message_stream.add_message(role: :system, content: 'System prompt updated.')
+              else
+                @message_stream.add_message(role: :system, content: 'No active LLM session.')
+              end
+            else
+              @message_stream.add_message(role: :system, content: 'Usage: /system <prompt text>')
+            end
+            :handled
+          end
+
+          def handle_personality(input)
+            name = input.split(nil, 2)[1]
+            if name && PERSONALITIES.key?(name)
+              apply_personality(name)
+            elsif name
+              available = PERSONALITIES.keys.join(', ')
+              @message_stream.add_message(role: :system,
+                                          content: "Unknown personality '#{name}'. Available: #{available}")
+            else
+              current = @personality || 'default'
+              available = PERSONALITIES.keys.join(', ')
+              @message_stream.add_message(role: :system, content: "Current: #{current}\nAvailable: #{available}")
+            end
+            :handled
+          end
+
+          def apply_personality(name)
+            @personality = name
+            if @llm_chat.respond_to?(:with_instructions)
+              @llm_chat.with_instructions(PERSONALITIES[name])
+              @message_stream.add_message(role: :system, content: "Personality switched to: #{name}")
+            else
+              @message_stream.add_message(role: :system, content: "Personality set to: #{name} (no active LLM)")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        module SessionCommands
+          private
+
+          def handle_save(input)
+            name = input.split(nil, 2)[1] || @session_store.auto_session_name
+            @session_name = name
+            @session_store.save(name, messages: @message_stream.messages)
+            @status_bar.update(session: name)
+            @status_bar.notify(message: "Saved '#{name}'", level: :success, ttl: 3)
+            @message_stream.add_message(role: :system, content: "Session saved as '#{name}'.")
+            :handled
+          end
+
+          def handle_load(input)
+            name = input.split(nil, 2)[1]
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /load <session-name>')
+              return :handled
+            end
+            data = @session_store.load(name)
+            unless data
+              @message_stream.add_message(role: :system, content: "Session '#{name}' not found.")
+              return :handled
+            end
+            @message_stream.messages.replace(data[:messages])
+            @loaded_message_count = @message_stream.messages.size
+            @session_name = name
+            @status_bar.update(session: name)
+            @status_bar.notify(message: "Loaded '#{name}'", level: :info, ttl: 3)
+            @message_stream.add_message(role: :system,
+                                        content: "Session '#{name}' loaded (#{data[:messages].size} messages).")
+            :handled
+          end
+
+          def handle_sessions
+            sessions = @session_store.list
+            if sessions.empty?
+              @message_stream.add_message(role: :system, content: 'No saved sessions.')
+            else
+              lines = sessions.map { |s| "  #{s[:name]} - #{s[:message_count]} messages (#{s[:saved_at]})" }
+              @message_stream.add_message(role: :system, content: "Saved sessions:\n#{lines.join("\n")}")
+            end
+            :handled
+          end
+
+          def handle_delete(input)
+            name = input.split(nil, 2)[1]
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /delete <session-name>')
+              return :handled
+            end
+            @session_store.delete(name)
+            @message_stream.add_message(role: :system, content: "Session '#{name}' deleted.")
+            :handled
+          end
+
+          def handle_rename(input)
+            name = input.split(nil, 2)[1]
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /rename <new-name>')
+              return :handled
+            end
+
+            old_name = @session_name
+            @session_store.delete(old_name) if old_name != 'default'
+            @session_name = name
+            @status_bar.update(session: name)
+            @session_store.save(name, messages: @message_stream.messages)
+            @message_stream.add_message(role: :system, content: "Session renamed to '#{name}'.")
+            :handled
+          end
+
+          def auto_save_session
+            return if @message_stream.messages.empty?
+
+            if @session_name == 'default'
+              @session_name = @session_store.auto_session_name(messages: @message_stream.messages)
+            end
+            @session_store.save(@session_name, messages: @message_stream.messages)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        # rubocop:disable Metrics/ModuleLength
+        module UiCommands
+          TIPS = [
+            'Press Tab after / to auto-complete commands',
+            'Use /alias to create shortcuts (e.g., /alias s /save)',
+            'Press Ctrl+K to open the command palette',
+            'Use /grep for regex search (e.g., /grep error|warning)',
+            'Pin important messages with /pin, export with /bookmark',
+            'Use /compact 3 to keep only the last 3 message pairs',
+            "Press 'o' in Extensions browser to open gem homepage",
+            '/export html creates a styled dark-theme HTML export',
+            'Use /snippet save name to save assistant responses for reuse',
+            'The dashboard updates every 5 seconds; press r to refresh',
+            '/context shows your full session state at a glance',
+            'Use /personality technical for code-focused responses',
+            '/debug shows internal state counters in the status bar',
+            'Navigate dashboard panels with j/k or number keys 1-5',
+            'Use /diff to see new messages since a session was loaded'
+          ].freeze
+
+          HELP_TEXT = [
+            'SESSION : /save /load /sessions /delete /rename',
+            'CHAT    : /clear /undo /compact /copy /search /grep /diff /stats',
+            'LLM     : /model /system /personality /cost',
+            'NAV     : /dashboard /extensions /config /palette /hotkeys',
+            'DISPLAY : /theme /plan /debug /context /time /uptime',
+            'TOOLS   : /tools /export /bookmark /pin /pins /alias /snippet /history',
+            '',
+            'Hotkeys: Ctrl+D=dashboard  Ctrl+K=palette  Ctrl+S=sessions  Esc=back'
+          ].freeze
+
+          private
+
+          def handle_help
+            text = HELP_TEXT.join("\n")
+            if @app.respond_to?(:screen_manager) && @app.screen_manager
+              @app.screen_manager.show_overlay(text)
+            else
+              @message_stream.add_message(role: :system, content: text)
+            end
+            :handled
+          end
+
+          def handle_welcome
+            cfg = safe_config
+            @message_stream.add_message(
+              role: :system,
+              content: "Welcome#{", #{cfg[:name]}" if cfg[:name]}. Type /help for commands."
+            )
+            :handled
+          end
+
+          def handle_tips
+            tip = TIPS.sample
+            @message_stream.add_message(role: :system, content: "Tip: #{tip}")
+            :handled
+          end
+
+          def handle_clear
+            @message_stream.messages.clear
+            :handled
+          end
+
+          def handle_dashboard
+            if @app.respond_to?(:toggle_dashboard)
+              @app.toggle_dashboard
+            else
+              @message_stream.add_message(role: :system, content: 'Dashboard not available.')
+            end
+            :handled
+          end
+
+          def handle_hotkeys
+            if @app.respond_to?(:hotkeys)
+              bindings = @app.hotkeys.list
+              lines = bindings.map { |b| "#{b[:key].inspect} -> #{b[:description]}" }
+              text = lines.empty? ? 'No hotkeys registered.' : lines.join("\n")
+              @message_stream.add_message(role: :system, content: "Hotkeys:\n#{text}")
+            else
+              @message_stream.add_message(role: :system, content: 'Hotkeys not available.')
+            end
+            :handled
+          end
+
+          def handle_extensions_screen
+            require_relative '../screens/extensions'
+            screen = Screens::Extensions.new(@app, output: @output)
+            @app.screen_manager.push(screen)
+            :handled
+          rescue LoadError
+            @message_stream.add_message(role: :system, content: 'Extensions screen not available.')
+            :handled
+          end
+
+          def handle_config_screen
+            require_relative '../screens/config'
+            screen = Screens::Config.new(@app, output: @output)
+            @app.screen_manager.push(screen)
+            :handled
+          rescue LoadError
+            @message_stream.add_message(role: :system, content: 'Config screen not available.')
+            :handled
+          end
+
+          def handle_palette
+            require_relative '../components/command_palette'
+            palette = Components::CommandPalette.new(session_store: @session_store)
+            selection = palette.select_with_prompt(output: @output)
+            return :handled unless selection
+
+            if selection.start_with?('/')
+              handle_slash_command(selection)
+            else
+              dispatch_screen_by_name(selection)
+            end
+            :handled
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def handle_context
+            cfg = safe_config
+            model_info = @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : (cfg[:provider] || 'none')
+            sys_prompt = if @llm_chat.respond_to?(:instructions) && @llm_chat.instructions
+                           truncate_text(@llm_chat.instructions.to_s, 80)
+                         else
+                           'default'
+                         end
+            lines = [
+              'Session Context:',
+              "  Model/Provider : #{model_info}",
+              "  Personality    : #{@personality || 'default'}",
+              "  Plan mode      : #{@plan_mode ? 'on' : 'off'}",
+              "  System prompt  : #{sys_prompt}",
+              "  Session        : #{@session_name}",
+              "  Messages       : #{@message_stream.messages.size}",
+              "  Pinned         : #{@pinned_messages.size}",
+              "  Tokens         : #{@token_tracker.summary}"
+            ]
+            @message_stream.add_message(role: :system, content: lines.join("\n"))
+            :handled
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def handle_stats
+            @message_stream.add_message(role: :system, content: build_stats_lines.join("\n"))
+            :handled
+          end
+
+          def handle_debug
+            @debug_mode = !@debug_mode
+            if @debug_mode
+              @status_bar.update(debug_mode: true)
+              @message_stream.add_message(role: :system, content: 'Debug mode ON -- internal state shown below.')
+            else
+              @status_bar.update(debug_mode: false)
+              @message_stream.add_message(role: :system, content: 'Debug mode OFF.')
+            end
+            :handled
+          end
+
+          def handle_history
+            entries = @input_bar.history
+            if entries.empty?
+              @message_stream.add_message(role: :system, content: 'No input history.')
+            else
+              recent = entries.last(20)
+              lines = recent.each_with_index.map { |entry, i| "  #{i + 1}. #{entry}" }
+              @message_stream.add_message(role: :system,
+                                          content: "Input history (last #{recent.size}):\n#{lines.join("\n")}")
+            end
+            :handled
+          end
+
+          def handle_uptime
+            elapsed = Time.now - @session_start
+            hours   = (elapsed / 3600).to_i
+            minutes = ((elapsed % 3600) / 60).to_i
+            seconds = (elapsed % 60).to_i
+            @message_stream.add_message(role: :system, content: "Session uptime: #{hours}h #{minutes}m #{seconds}s")
+            :handled
+          end
+
+          def handle_time
+            now = Time.now
+            tz = now.zone || 'local'
+            @message_stream.add_message(
+              role: :system,
+              content: "Current time: #{now.strftime('%Y-%m-%d %H:%M:%S')} #{tz}"
+            )
+            :handled
+          end
+
+          def dispatch_screen_by_name(name)
+            case name
+            when 'dashboard' then handle_dashboard
+            when 'extensions' then handle_extensions_screen
+            when 'config' then handle_config_screen
+            end
+          end
+
+          def build_stats_lines
+            msgs = @message_stream.messages
+            counts = count_by_role(msgs)
+            total_chars = msgs.sum { |m| m[:content].to_s.length }
+            lines = stats_header_lines(msgs, counts, total_chars)
+            lines << "  Tool calls: #{counts[:tool]}" if counts[:tool].positive?
+            lines
+          end
+
+          def count_by_role(msgs)
+            %i[user assistant system tool].to_h { |role| [role, msgs.count { |m| m[:role] == role }] }
+          end
+
+          def stats_header_lines(msgs, counts, total_chars)
+            [
+              "Messages: #{msgs.size} total",
+              "  User: #{counts[:user]}, Assistant: #{counts[:assistant]}, System: #{counts[:system]}",
+              "Characters: #{format_stat_number(total_chars)}",
+              "Session: #{@session_name}",
+              "Tokens: #{@token_tracker.summary}"
+            ]
+          end
+
+          def format_stat_number(num)
+            num.to_s.chars.reverse.each_slice(3).map(&:join).join(',').reverse
+          end
+        end
+        # rubocop:enable Metrics/ModuleLength
+      end
+    end
+  end
+end