legion-tty 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e2b8a679110725634b3db870bb623fc8f5cef89706890f9c57c579490c85114
-  data.tar.gz: 6487e27647ed48406731a9c0c1bf1664b64831b60139dd698ae794d2dc8d3871
+  metadata.gz: 9506a28fb68d7623dd1e70e2b69b80e80b2a96486c068dbc2d13a7e2bd9a80ab
+  data.tar.gz: 7ce9e32334ba94891569b073e04246240d8b1637edb930f0c8c86ed80841a155
 SHA512:
-  metadata.gz: 9c89fb3dbcb807c628889b2b60566b3b23cad1356c26de42cd1d02d75a2977e7856528b0193e8bb9dd630ee4cf52b2b55e06e009c8fc3e34550a1712d6768b68
-  data.tar.gz: ae426495d1eb8708723a5c2804a4a77e4a557480324c23b370b0ebe324ea1a7ece957665b133f7810952f03f586cb0e87dcef3e1c78e9fcde81fe13e0e6e4760
+  metadata.gz: b7cf759adc8fcaad726906fd6e95d12a00d5e09bbf3724685a1fae91bdd31d9df31036bc4d826cc7b756f2cb97ae2d560290dbb6c1f0473b8334da48508d5a39
+  data.tar.gz: 7fcce87bc7f909f1e5b5c6d468871860a0a2be6f621a8b446d7948cf2761bf354035911d946c134b74d04b226e19f2b174c010d1fb9e7a39533162f826883865

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.4.12] - 2026-03-19
+
+### Added
+- `/grep <pattern>` command: regex search across message history (case-insensitive, with RegexpError handling)
+- `/time` command: display current date, time, and timezone
+
+### Changed
+- Refactored Chat screen into 6 concern modules (chat.rb 1220 -> 466 lines):
+  - `chat/session_commands.rb` — save/load/sessions/delete/rename
+  - `chat/export_commands.rb` — export/bookmark/html/json/markdown
+  - `chat/message_commands.rb` — compact/copy/diff/search/grep/undo/pin/pins
+  - `chat/ui_commands.rb` — help/clear/dashboard/hotkeys/palette/context/stats/debug/history/uptime/time
+  - `chat/model_commands.rb` — model/system/personality switching
+  - `chat/custom_commands.rb` — alias/snippet management
+
 ## [0.4.11] - 2026-03-19
 
 ### Added

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        # rubocop:disable Metrics/ModuleLength
+        module CustomCommands
+          private
+
+          def handle_alias(input)
+            parts = input.split(nil, 3)
+            if parts.size < 2
+              if @aliases.empty?
+                @message_stream.add_message(role: :system, content: 'No aliases defined.')
+              else
+                lines = @aliases.map { |k, v| "  #{k} => #{v}" }
+                @message_stream.add_message(role: :system, content: "Aliases:\n#{lines.join("\n")}")
+              end
+              return :handled
+            end
+
+            shortname = parts[1]
+            expansion = parts[2]
+            unless expansion
+              @message_stream.add_message(role: :system, content: 'Usage: /alias <shortname> <command and args>')
+              return :handled
+            end
+
+            alias_key = shortname.start_with?('/') ? shortname : "/#{shortname}"
+            @aliases[alias_key] = expansion
+            @message_stream.add_message(role: :system, content: "Alias created: #{alias_key} => #{expansion}")
+            :handled
+          end
+
+          def handle_snippet(input)
+            parts = input.split(nil, 3)
+            subcommand = parts[1]
+            name = parts[2]
+
+            case subcommand
+            when 'save'
+              snippet_save(name)
+            when 'load'
+              snippet_load(name)
+            when 'list'
+              snippet_list
+            when 'delete'
+              snippet_delete(name)
+            else
+              @message_stream.add_message(
+                role: :system,
+                content: 'Usage: /snippet save|load|list|delete <name>'
+              )
+            end
+            :handled
+          end
+
+          def snippet_dir
+            File.expand_path('~/.legionio/snippets')
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def snippet_save(name)
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /snippet save <name>')
+              return
+            end
+
+            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 save as snippet.')
+              return
+            end
+
+            require 'fileutils'
+            FileUtils.mkdir_p(snippet_dir)
+            path = File.join(snippet_dir, "#{name}.txt")
+            File.write(path, last_assistant[:content].to_s)
+            @snippets[name] = last_assistant[:content].to_s
+            @message_stream.add_message(role: :system, content: "Snippet '#{name}' saved.")
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def snippet_load(name)
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /snippet load <name>')
+              return
+            end
+
+            content = @snippets[name]
+            if content.nil?
+              path = File.join(snippet_dir, "#{name}.txt")
+              content = File.read(path) if File.exist?(path)
+            end
+
+            unless content
+              @message_stream.add_message(role: :system, content: "Snippet '#{name}' not found.")
+              return
+            end
+
+            @snippets[name] = content
+            @message_stream.add_message(role: :user, content: content)
+            @message_stream.add_message(role: :system, content: "Snippet '#{name}' inserted.")
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def snippet_list
+            disk_snippets = Dir.glob(File.join(snippet_dir, '*.txt')).map { |f| File.basename(f, '.txt') }
+            all_names = (@snippets.keys + disk_snippets).uniq.sort
+
+            if all_names.empty?
+              @message_stream.add_message(role: :system, content: 'No snippets saved.')
+              return
+            end
+
+            lines = all_names.map do |sname|
+              content = @snippets[sname] || begin
+                path = File.join(snippet_dir, "#{sname}.txt")
+                File.exist?(path) ? File.read(path) : ''
+              end
+              "  #{sname}: #{truncate_text(content.to_s, 60)}"
+            end
+            @message_stream.add_message(role: :system, content: "Snippets (#{all_names.size}):\n#{lines.join("\n")}")
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def snippet_delete(name)
+            unless name
+              @message_stream.add_message(role: :system, content: 'Usage: /snippet delete <name>')
+              return
+            end
+
+            @snippets.delete(name)
+            path = File.join(snippet_dir, "#{name}.txt")
+            if File.exist?(path)
+              File.delete(path)
+              @message_stream.add_message(role: :system, content: "Snippet '#{name}' deleted.")
+            else
+              @message_stream.add_message(role: :system, content: "Snippet '#{name}' not found.")
+            end
+          end
+        end
+        # rubocop:enable Metrics/ModuleLength
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Screens
+      class Chat < Base
+        module ExportCommands
+          private
+
+          def handle_export(input)
+            require 'fileutils'
+            path = build_export_path(input)
+            dispatch_export(path, input.split[1]&.downcase)
+            @status_bar.notify(message: 'Exported', level: :success, ttl: 3)
+            @message_stream.add_message(role: :system, content: "Exported to: #{path}")
+            :handled
+          rescue StandardError => e
+            @message_stream.add_message(role: :system, content: "Export failed: #{e.message}")
+            :handled
+          end
+
+          def build_export_path(input)
+            format = input.split[1]&.downcase
+            format = 'md' unless %w[json md html].include?(format)
+            exports_dir = File.expand_path('~/.legionio/exports')
+            FileUtils.mkdir_p(exports_dir)
+            timestamp = Time.now.strftime('%Y%m%d-%H%M%S')
+            ext = { 'json' => 'json', 'md' => 'md', 'html' => 'html' }[format]
+            File.join(exports_dir, "chat-#{timestamp}.#{ext}")
+          end
+
+          def dispatch_export(path, format)
+            if format == 'json'
+              export_json(path)
+            elsif format == 'html'
+              export_html(path)
+            else
+              export_markdown(path)
+            end
+          end
+
+          def export_markdown(path)
+            lines = ["# Chat Export\n", "_Exported: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}_\n\n---\n"]
+            @message_stream.messages.each do |msg|
+              role_label = msg[:role].to_s.capitalize
+              lines << "\n**#{role_label}**\n\n#{msg[:content]}\n"
+            end
+            File.write(path, lines.join)
+          end
+
+          def export_json(path)
+            require 'json'
+            data = {
+              exported_at: Time.now.iso8601,
+              token_summary: @token_tracker.summary,
+              messages: @message_stream.messages.map { |m| { role: m[:role].to_s, content: m[:content] } }
+            }
+            File.write(path, ::JSON.pretty_generate(data))
+          end
+
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          def export_html(path)
+            lines = [
+              '<!DOCTYPE html><html><head>',
+              '<meta charset="utf-8">',
+              '<title>Chat Export</title>',
+              '<style>',
+              'body { font-family: system-ui; max-width: 800px; margin: 0 auto; ' \
+              'padding: 20px; background: #1e1b2e; color: #d0cce6; }',
+              '.msg { margin: 12px 0; padding: 8px 12px; border-radius: 8px; }',
+              '.user { background: #2a2640; }',
+              '.assistant { background: #1a1730; }',
+              '.system { background: #25223a; color: #8b85a8; font-style: italic; }',
+              '.role { font-weight: bold; color: #9d91e6; font-size: 0.85em; }',
+              '</style></head><body>',
+              '<h1>Chat Export</h1>',
+              "<p>Exported: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}</p>"
+            ]
+            @message_stream.messages.each do |msg|
+              role = msg[:role].to_s
+              content = escape_html(msg[:content].to_s).gsub("\n", '<br>')
+              lines << "<div class='msg #{role}'>"
+              lines << "<span class='role'>#{role.capitalize}</span>"
+              lines << "<p>#{content}</p>"
+              lines << '</div>'
+            end
+            lines << '</body></html>'
+            File.write(path, lines.join("\n"))
+          end
+          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+          def escape_html(text)
+            text.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def handle_bookmark
+            require 'fileutils'
+            if @pinned_messages.empty?
+              @message_stream.add_message(role: :system, content: 'No pinned messages to export.')
+              return :handled
+            end
+
+            exports_dir = File.expand_path('~/.legionio/exports')
+            FileUtils.mkdir_p(exports_dir)
+            timestamp = Time.now.strftime('%Y%m%d-%H%M%S')
+            path = File.join(exports_dir, "bookmarks-#{timestamp}.md")
+            lines = ["# Pinned Messages\n", "_Exported: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}_\n\n---\n"]
+            @pinned_messages.each_with_index do |msg, i|
+              role_label = msg[:role].to_s.capitalize
+              lines << "\n## Bookmark #{i + 1} (#{role_label})\n\n#{msg[:content]}\n"
+            end
+            File.write(path, lines.join)
+            @message_stream.add_message(role: :system, content: "Bookmarks exported to: #{path}")
+            :handled
+          rescue StandardError => e
+            @message_stream.add_message(role: :system, content: "Bookmark export failed: #{e.message}")
+            :handled
+          end
+          # rubocop:enable Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

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