legion-tty 0.4.22 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45ef88ce519140b5056ce0b934f3c3512781a4f26e30dc74203c431e6f20cc3c
-  data.tar.gz: ba632f83ea2022683c097b5451849bf129287c46959a050a8db90b356abe1f29
+  metadata.gz: ab1a18bdbec9078051e19b84ede94cdaacb600ed12006674dc5696f711230349
+  data.tar.gz: 6735876baede0f4fd45637f6a5cb0cef4284f7117298fa96cb97c8ca667a23d4
 SHA512:
-  metadata.gz: affafac87b03a47e29ae08bfe5815ba9eb8f72de5fc3feda9350b2871021537f6319261177de1a20f349b8d38cda3295d6b5cca6ff941dbe9414744fa27562e5
-  data.tar.gz: bf14853b34688cd959cf6301a56542ec9448fc9f4db2fb2489e7c6aeec3d56e08fc6e44c1627dc31c33631a8b9291717786032dee7ab72b566c545693ca2b57e
+  metadata.gz: '01294f74d7805fb5aad66aa1538ffe38cb1f8b407aaaa662d90cacaf7f8c0b4e787257636007f8a74e88e1e13b76a5432da4a2ff47aad0dd5b6f81852116ddfb'
+  data.tar.gz: 789298565c5285d7ef1787fd7dfbf8034b181f57f3cab243cd4b424712b0ec7251836e8c8f5ff3b79faf4b0d98c5416e919e8cf80c42df09adbe443d5b77905f

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.4.24] - 2026-03-19
+
+### Added
+- `/mark <label>` command: insert named markers/bookmarks in conversation, list all markers
+- `/freq` command: word frequency analysis with top 20 words (excludes stop words)
+- `/draft <text>` command: save text to draft buffer, show/clear/send draft
+- `/revise <text>` command: replace content of last user message
+- `/color [on|off]` command: toggle colorized output (strip ANSI codes when off)
+- `/timestamps [on|off]` command: toggle timestamp display on messages
+- `/top` command: scroll to top of message history
+- `/bottom` command: scroll to bottom of message history
+- `/head [N]` command: peek at first N messages (default 5)
+- `/tail [N]` command: peek at last N messages (default 5)
+
+## [0.4.23] - 2026-03-19
+
+### Added
+- `/wrap [N|off]` command: set custom word wrap width for message display
+- `/number [on|off]` command: toggle message numbering with `[N]` prefix
+- `/echo <text>` command: add user-defined system messages (notes/markers)
+- `/env` command: show environment info (Ruby version, platform, terminal, PID, Legion gems)
+- `/speak [on|off]` command: toggle text-to-speech for assistant messages (macOS only, via `say`)
+- `/silent` command: toggle silent mode (responses tracked but not displayed), `[SILENT]` indicator
+- `/ls [path]` command: list directory contents with directory markers
+- `/pwd` command: show current working directory
+
 ## [0.4.22] - 2026-03-19
 
 ### Added

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

@@ -9,7 +9,8 @@ module Legion
       # rubocop:disable Metrics/ClassLength
       class MessageStream
         attr_reader :messages, :scroll_offset
-        attr_accessor :mute_system, :highlights, :filter, :truncate_limit
+        attr_accessor :mute_system, :silent_mode, :highlights, :filter, :truncate_limit, :wrap_width, :show_numbers,
+                      :colorize, :show_timestamps
 
         HIGHLIGHT_COLOR = "\e[1;33m"
         HIGHLIGHT_RESET = "\e[0m"
@@ -18,7 +19,12 @@ module Legion
           @messages = []
           @scroll_offset = 0
           @mute_system = false
+          @silent_mode = false
           @highlights = []
+          @wrap_width = nil
+          @show_numbers = false
+          @colorize = true
+          @show_timestamps = true
         end
 
         def add_message(role:, content:)
@@ -61,11 +67,13 @@ module Legion
         end
 
         def render(width:, height:)
-          all_lines = build_all_lines(width)
+          effective_width = @wrap_width || width
+          all_lines = build_all_lines(effective_width)
           total = all_lines.size
           start_idx = [total - height - @scroll_offset, 0].max
           start_idx = [start_idx, total].min
           result = all_lines[start_idx, height] || []
+          result = result.map { |l| strip_ansi(l) } unless @colorize
           @last_visible_count = result.size
           result
         end
@@ -77,10 +85,11 @@ module Legion
         private
 
         def build_all_lines(width)
-          filtered_messages.flat_map do |msg|
+          filtered_messages.each_with_index.flat_map do |msg, idx|
             next [] if @mute_system && msg[:role] == :system
+            next [] if @silent_mode && msg[:role] == :assistant
 
-            render_message(msg, width)
+            render_message(msg, width, @show_numbers ? idx + 1 : nil)
           end
         end
 
@@ -99,8 +108,17 @@ module Legion
           end
         end
 
-        def render_message(msg, width)
-          role_lines(msg, width) + panel_lines(msg, width)
+        def render_message(msg, width, number = nil)
+          lines = role_lines(msg, width) + panel_lines(msg, width)
+          prepend_number(lines, number)
+        end
+
+        def prepend_number(lines, number)
+          return lines unless number
+
+          lines.each_with_index.map do |line, i|
+            i == 1 ? "[#{number}] #{line}" : line
+          end
         end
 
         def role_lines(msg, width)
@@ -114,15 +132,18 @@ module Legion
         end
 
         def user_lines(msg, _width)
-          ts = format_timestamp(msg[:timestamp])
-          header = "#{Theme.c(:accent, 'You')} #{Theme.c(:muted, ts)}"
           content = apply_highlights(msg[:content].to_s)
-          lines = ['', "#{header}: #{content}"]
+          lines = ['', "#{user_header(msg[:timestamp])}: #{content}"]
           lines << reaction_line(msg) if msg[:reactions]&.any?
           lines.concat(annotation_lines(msg)) if msg[:annotations]&.any?
           lines
         end
 
+        def user_header(timestamp)
+          ts = @show_timestamps ? format_timestamp(timestamp) : ''
+          ts.empty? ? Theme.c(:accent, 'You') : "#{Theme.c(:accent, 'You')} #{Theme.c(:muted, ts)}"
+        end
+
         def format_timestamp(time)
           return '' unless time
 
@@ -195,6 +216,10 @@ module Legion
           panel.instance_variable_set(:@result, result) if result
           panel.instance_variable_set(:@error, error) if error
         end
+
+        def strip_ansi(text)
+          text.gsub(/\e\[[0-9;]*m/, '')
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end

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

@@ -10,7 +10,7 @@ module Legion
       class StatusBar
         def initialize
           @state = { model: nil, tokens: 0, cost: 0.0, session: 'default', thinking: false, plan_mode: false,
-                     debug_mode: false, message_count: 0, multiline: false }
+                     debug_mode: false, message_count: 0, multiline: false, silent: false }
           @notifications = []
         end
 
@@ -42,6 +42,7 @@ module Legion
           [
             model_segment,
             plan_segment,
+            silent_segment,
             multiline_segment,
             debug_segment,
             thinking_segment,
@@ -70,6 +71,12 @@ module Legion
           Theme.c(:accent, '[ML]')
         end
 
+        def silent_segment
+          return nil unless @state[:silent]
+
+          Theme.c(:warning, '[SILENT]')
+        end
+
         def debug_segment
           return nil unless @state[:debug_mode]
 

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

@@ -560,6 +560,101 @@ module Legion
             @message_stream.add_message(role: :system, content: "Truncated to last #{n} messages.")
             :handled
           end
+
+          def handle_mark(input)
+            label = input.split(nil, 2)[1]
+            return list_markers if label.nil?
+
+            msg = { role: :system, content: "--- #{label} ---", marker: label }
+            @message_stream.messages << msg
+            @status_bar.update(message_count: @message_stream.messages.size)
+            :handled
+          end
+
+          def list_markers
+            markers = @message_stream.messages.each_with_index.select { |m, _| m[:marker] }
+            if markers.empty?
+              @message_stream.add_message(role: :system, content: 'No markers set.')
+            else
+              lines = markers.map { |m, i| "  [#{i}] #{m[:content]}" }
+              @message_stream.add_message(role: :system, content: "Markers:\n#{lines.join("\n")}")
+            end
+            :handled
+          end
+
+          def handle_head(input)
+            n = (input.split(nil, 2)[1] || '5').to_i.clamp(1, 500)
+            msgs = @message_stream.messages.first(n)
+            if msgs.empty?
+              @message_stream.add_message(role: :system, content: 'No messages.')
+              return :handled
+            end
+
+            lines = msgs.map { |m| "  [#{m[:role]}] #{truncate_text(m[:content].to_s, 80)}" }
+            @message_stream.add_message(role: :system, content: "First #{msgs.size} message(s):\n#{lines.join("\n")}")
+            :handled
+          end
+
+          def handle_tail(input)
+            n = (input.split(nil, 2)[1] || '5').to_i.clamp(1, 500)
+            msgs = @message_stream.messages.last(n)
+            if msgs.empty?
+              @message_stream.add_message(role: :system, content: 'No messages.')
+              return :handled
+            end
+
+            lines = msgs.map { |m| "  [#{m[:role]}] #{truncate_text(m[:content].to_s, 80)}" }
+            @message_stream.add_message(role: :system, content: "Last #{msgs.size} message(s):\n#{lines.join("\n")}")
+            :handled
+          end
+
+          def handle_draft(input)
+            arg = input.split(nil, 2)[1]
+            case arg
+            when nil
+              content = @draft ? "Draft: #{@draft}" : 'No draft saved.'
+              @message_stream.add_message(role: :system, content: content)
+            when 'clear'
+              @draft = nil
+              @message_stream.add_message(role: :system, content: 'Draft cleared.')
+            when 'send'
+              return draft_send
+            else
+              @draft = arg
+              @message_stream.add_message(role: :system, content: "Draft saved: #{@draft}")
+            end
+            :handled
+          end
+
+          def draft_send
+            unless @draft
+              @message_stream.add_message(role: :system, content: 'No draft to send.')
+              return :handled
+            end
+
+            text = @draft
+            @draft = nil
+            handle_user_message(text)
+            :handled
+          end
+
+          def handle_revise(input)
+            new_content = input.split(nil, 2)[1]
+            unless new_content
+              @message_stream.add_message(role: :system, content: 'Usage: /revise <new content>')
+              return :handled
+            end
+
+            msg = @message_stream.messages.reverse.find { |m| m[:role] == :user }
+            unless msg
+              @message_stream.add_message(role: :system, content: 'No user message to revise.')
+              return :handled
+            end
+
+            msg[:content] = new_content
+            @message_stream.add_message(role: :system, content: "Revised: #{new_content}")
+            :handled
+          end
         end
       end
     end

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

@@ -132,6 +132,28 @@ module Legion
             send_to_llm(@last_user_input)
             :handled
           end
+
+          def handle_speak(input)
+            unless RUBY_PLATFORM =~ /darwin/
+              @message_stream.add_message(role: :system, content: 'Text-to-speech is only available on macOS.')
+              return :handled
+            end
+
+            arg = input.split(nil, 2)[1]&.strip&.downcase
+            case arg
+            when 'on'
+              @speak_mode = true
+              @message_stream.add_message(role: :system, content: 'Text-to-speech ON.')
+            when 'off'
+              @speak_mode = false
+              @message_stream.add_message(role: :system, content: 'Text-to-speech OFF.')
+            else
+              @speak_mode = !@speak_mode
+              state = @speak_mode ? 'ON' : 'OFF'
+              @message_stream.add_message(role: :system, content: "Text-to-speech #{state}.")
+            end
+            :handled
+          end
         end
       end
     end

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

@@ -37,6 +37,12 @@ module Legion
 
           CALC_SAFE_PATTERN = %r{\A[\d\s+\-*/.()%]*\z}
           CALC_MATH_PATTERN = %r{\A[\d\s+\-*/.()%]*(Math\.\w+\([\d\s+\-*/.()%,]*\)[\d\s+\-*/.()%]*)*\z}
+          FREQ_STOP_WORDS = %w[
+            the a an is are was were be been have has had do does did will would could should
+            may might can shall to of in for on with at by from it this that i you we they
+            he she my your our their and or but not no if then so as
+          ].freeze
+          FREQ_ROW_FMT = '  %<rank>2d. %-<word>20s %<count>5d  %<pct>5.1f%%'
 
           private
 
@@ -471,10 +477,75 @@ module Legion
             end
           end
 
+          def handle_wrap(input)
+            arg = input.split(nil, 2)[1]&.strip
+            if arg.nil?
+              status = @message_stream.wrap_width ? "#{@message_stream.wrap_width} columns" : 'off'
+              @message_stream.add_message(role: :system, content: "Wrap: #{status}")
+            elsif arg == 'off'
+              @message_stream.wrap_width = nil
+              @message_stream.add_message(role: :system, content: 'Word wrap disabled.')
+            else
+              n = arg.to_i
+              if n >= 20
+                @message_stream.wrap_width = n
+                @message_stream.add_message(role: :system, content: "Word wrap set to #{n} columns.")
+              else
+                @message_stream.add_message(role: :system, content: 'Usage: /wrap [N|off]')
+              end
+            end
+            :handled
+          end
+
+          def handle_number(input)
+            arg = input.split(nil, 2)[1]&.strip
+            case arg
+            when 'on'
+              @message_stream.show_numbers = true
+              @message_stream.add_message(role: :system, content: 'Message numbering ON.')
+            when 'off'
+              @message_stream.show_numbers = false
+              @message_stream.add_message(role: :system, content: 'Message numbering OFF.')
+            else
+              @message_stream.show_numbers = !@message_stream.show_numbers
+              state = @message_stream.show_numbers ? 'ON' : 'OFF'
+              @message_stream.add_message(role: :system, content: "Message numbering #{state}.")
+            end
+            :handled
+          end
+
           def safe_calc_expr?(expr)
             CALC_SAFE_PATTERN.match?(expr) || CALC_MATH_PATTERN.match?(expr)
           end
 
+          def handle_echo(input)
+            text = input.split(nil, 2)[1]&.strip
+            unless text && !text.empty?
+              @message_stream.add_message(role: :system, content: 'Usage: /echo <text>')
+              return :handled
+            end
+
+            @message_stream.add_message(role: :system, content: text)
+            :handled
+          end
+
+          def handle_env
+            width  = terminal_width
+            height = terminal_height
+            legion_gems = Gem::Specification.select { |s| s.name.start_with?('legion-', 'lex-') }
+                                            .map { |s| "#{s.name} #{s.version}" }
+                                            .sort
+            lines = [
+              "Ruby:     #{RUBY_VERSION} (#{RUBY_PLATFORM})",
+              "Terminal: #{width}x#{height}",
+              "PID:      #{::Process.pid}",
+              "TTY:      legion-tty v#{Legion::TTY::VERSION}",
+              "Gems (#{legion_gems.size}): #{legion_gems.join(', ')}"
+            ]
+            @message_stream.add_message(role: :system, content: lines.join("\n"))
+            :handled
+          end
+
           # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           def handle_summary
             msgs = @message_stream.messages
@@ -541,6 +612,101 @@ module Legion
           rescue StandardError => e
             raise "command failed: #{e.message}"
           end
+
+          # rubocop:disable Metrics/AbcSize
+          def handle_ls(input)
+            path = File.expand_path(input.split(nil, 2)[1]&.strip || '.')
+            entries = Dir.entries(path).sort.reject { |e| ['.', '..'].include?(e) }
+            entries = entries.map { |e| File.directory?(File.join(path, e)) ? "#{e}/" : e }
+            @message_stream.add_message(role: :system, content: "#{path}:\n#{entries.join("\n")}")
+            :handled
+          rescue Errno::ENOENT, Errno::EACCES => e
+            @message_stream.add_message(role: :system, content: "ls: #{e.message}")
+            :handled
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def handle_pwd
+            @message_stream.add_message(role: :system, content: Dir.pwd)
+            :handled
+          end
+
+          def handle_silent
+            @silent_mode = !@silent_mode
+            @message_stream.silent_mode = @silent_mode
+            if @silent_mode
+              @status_bar.update(silent: true)
+              @message_stream.add_message(role: :system, content: 'Silent mode ON -- assistant responses hidden.')
+            else
+              @status_bar.update(silent: false)
+              @message_stream.add_message(role: :system, content: 'Silent mode OFF -- assistant responses visible.')
+            end
+            :handled
+          end
+
+          def handle_color(input)
+            arg = input.split(nil, 2)[1]&.strip
+            new_state = case arg
+                        when 'on'  then true
+                        when 'off' then false
+                        else            !@message_stream.colorize
+                        end
+            @message_stream.colorize = new_state
+            state_label = new_state ? 'ON' : 'OFF'
+            @message_stream.add_message(role: :system, content: "Color output #{state_label}.")
+            :handled
+          end
+
+          def handle_timestamps(input)
+            arg = input.split(nil, 2)[1]&.strip
+            new_state = case arg
+                        when 'on'  then true
+                        when 'off' then false
+                        else            !@message_stream.show_timestamps
+                        end
+            @message_stream.show_timestamps = new_state
+            state_label = new_state ? 'ON' : 'OFF'
+            @message_stream.add_message(role: :system, content: "Timestamps #{state_label}.")
+            :handled
+          end
+
+          def handle_top
+            @message_stream.scroll_up(@message_stream.messages.size * 5)
+            :handled
+          end
+
+          def handle_bottom
+            @message_stream.scroll_down(@message_stream.scroll_offset)
+            :handled
+          end
+
+          def handle_freq
+            words = collect_freq_words
+            if words.empty?
+              @message_stream.add_message(role: :system, content: 'No words to analyse.')
+              return :handled
+            end
+
+            top = words.tally.sort_by { |_, c| -c }.first(20)
+            header = '    #  word                 count      %'
+            lines = format_freq_lines(top, words.size)
+            @message_stream.add_message(role: :system,
+                                        content: "Word frequency (top #{top.size}):\n#{header}\n#{lines.join("\n")}")
+            :handled
+          end
+
+          def collect_freq_words
+            @message_stream.messages
+                           .flat_map { |m| m[:content].to_s.downcase.scan(/[a-z']+/) }
+                           .reject { |w| FREQ_STOP_WORDS.include?(w) || w.length < 2 }
+          end
+
+          def format_freq_lines(top, total)
+            top.map.with_index(1) do |(word, count), rank|
+              pct = (count.to_f / total * 100).round(1)
+              format(FREQ_ROW_FMT, rank: rank, word: word, count: count, pct: pct)
+            end
+          end
         end
       end
     end

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

@@ -37,7 +37,15 @@ module Legion
                             /annotate /annotations /filter /truncate
                             /tee /pipe
                             /archive /archives
-                            /calc /rand].freeze
+                            /calc /rand
+                            /echo /env
+                            /ls /pwd
+                            /wrap /number
+                            /speak /silent
+                            /color /timestamps
+                            /top /bottom /head /tail
+                            /draft /revise
+                            /mark /freq].freeze
 
         PERSONALITIES = {
           'default' => 'You are Legion, an async cognition engine and AI assistant. Be helpful and concise.',
@@ -79,6 +87,9 @@ module Legion
           @last_user_input = nil
           @highlights = []
           @multiline_mode = false
+          @speak_mode = false
+          @silent_mode = false
+          @draft = nil
         end
 
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
@@ -244,20 +255,35 @@ module Legion
           send_via_direct(message)
         end
 
+        # rubocop:disable Metrics/AbcSize
         def send_via_direct(message)
           return unless @llm_chat
 
           @status_bar.update(thinking: true)
           render_screen
           start_time = Time.now
+          response_text = +''
           response = @llm_chat.ask(message) do |chunk|
             @status_bar.update(thinking: false)
-            @message_stream.append_streaming(chunk.content) if chunk.content
+            if chunk.content
+              response_text << chunk.content
+              @message_stream.append_streaming(chunk.content)
+            end
             render_screen
           end
           record_response_time(Time.now - start_time)
           @status_bar.update(thinking: false)
           track_response_tokens(response)
+          speak_response(response_text) if @speak_mode
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def speak_response(text)
+          return unless RUBY_PLATFORM =~ /darwin/
+
+          ::Process.spawn('say', text[0..500], err: '/dev/null', out: '/dev/null')
+        rescue StandardError
+          nil
         end
 
         def record_response_time(elapsed)
@@ -448,6 +474,24 @@ module Legion
           when '/archives' then handle_archives
           when '/calc' then handle_calc(input)
           when '/rand' then handle_rand(input)
+          when '/echo' then handle_echo(input)
+          when '/env' then handle_env
+          when '/ls' then handle_ls(input)
+          when '/pwd' then handle_pwd
+          when '/wrap' then handle_wrap(input)
+          when '/number' then handle_number(input)
+          when '/speak' then handle_speak(input)
+          when '/silent' then handle_silent
+          when '/color' then handle_color(input)
+          when '/timestamps' then handle_timestamps(input)
+          when '/top' then handle_top
+          when '/bottom' then handle_bottom
+          when '/head' then handle_head(input)
+          when '/tail' then handle_tail(input)
+          when '/draft' then handle_draft(input)
+          when '/revise' then handle_revise(input)
+          when '/mark' then handle_mark(input)
+          when '/freq' then handle_freq
           else :handled
           end
         end

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.22'
+    VERSION = '0.4.24'
   end
 end

metadata

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