legion-tty 0.4.40 → 0.4.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60e92790f0f6281b48346af3972e2631f1952b3b68f3d51922aa52da8682cfc9
-  data.tar.gz: 85491c70182ced9142b483c4edd903f3e5948bac1544c01cba69a86f565d2483
+  metadata.gz: 544115343036952adfc2f3accc8ce189ec8bb13c06f04ce383d0536549118e49
+  data.tar.gz: 806f22df6bed2c34ce6c47c6eab8c1af6bb611cc458db878087a86163f7e0248
 SHA512:
-  metadata.gz: 757d74c3e7e0d7711cc9bb0cb410c145e7e8ca31d484d62ad53160df64c34205be19d6eb0fa91d7aede125af63ff1d005f596ea10c285fcbdc97adb5c74eee19
-  data.tar.gz: df6acc61f03cfc4631ccd28eaea40813314aadc8211497e857507ac7453ab700952bf6588a4d34016d3d5196651680583a293ff1bfba204101408b62a5c7fd4d
+  metadata.gz: 4a90450fe8ba541b1823f43cfc89eb97ed2ef6185029afffc022771c87f8909583fab80715098789240b8bab4ee3c8c2ae240987dc9630352c76d89ee3acad6a
+  data.tar.gz: '0667478fd7867da23c0c5f4a83fdeac3056cc97ff18a2bf1dbe0c447f4a29088b0e1d6aafeb6d9b19ffc8a1784b4cd80f1a94a2d9ea5a2563fca063004020ee5'

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [0.4.42] - 2026-04-08
+
+### Changed
+- `DaemonClient` now uses `Legion::Logging::Helper` (structured logging via `log.info`/`log.debug`) instead of inline `Legion::Logging.method if defined?` guards for all logging and exception handling
+- Bumped `legion-logging` minimum dependency from `>= 1.2.8` to `>= 1.5.0` to use `handle_exception` from `Legion::Logging::Helper`
+- Extracted `store_manifest` and `parse_inference_response` private helpers to reduce method complexity in `fetch_manifest` and `inference`
+
+### Fixed
+- `KerberosProbe#days_in_month` used `Time.new(year, month, -1)` which raises `ArgumentError` for day `-1`; replaced with `Date.new(year, month, -1).day` (correct Ruby idiom for last day of month)
+
+## [0.4.41] - 2026-03-31
+
+### Added
+- `KeybindingManager`: context-aware keybinding system with named contexts (`global`, `chat`, `dashboard`, `extensions`, `config`, `command_palette`, `session_picker`, `history`), chord sequence support (`@pending_chord` state machine), `resolve(key, active_contexts:)` method, and user-customizable overrides via `~/.legionio/keybindings.json` (closes #10)
+- `Legion::TTY::Notify`: OS-level terminal notification module with auto-detection of iTerm2 (OSC 9), Kitty (`kitten notify`), Ghostty (OSC 99), Linux (`notify-send`), macOS (`osascript`), and bell fallback; settings integration via `notifications.terminal.enabled` / `notifications.terminal.backend` (closes #11)
+
+### Changed
+- `SessionStore#load` now normalizes both TTY v1 format and CLI legacy format (RubyLLM `model`+`stats`+`summary` fields) into a canonical `{ role: :symbol, content:, tool_panels: [] }` shape; fills in default `version`, `metadata`, `name`, and `saved_at` when absent (closes #9)
+- `SessionStore::SESSION_DIR` confirmed as `~/.legionio/sessions/` (no legacy `~/.legion/` references)
+
 ## [0.4.40] - 2026-03-28
 
 ### Changed

data/README.md

@@ -2,7 +2,7 @@
 
 Rich terminal UI for the LegionIO async cognition engine.
 
-**Version**: 0.4.35
+**Version**: 0.4.42
 
 Think Claude Code meets Codex CLI, but for LegionIO: onboarding wizard with identity detection, streaming AI chat shell with 115 slash commands, operational dashboard, extensions browser, config editor, and session persistence - all rendered with the [tty-ruby](https://ttytoolkit.org/) gem ecosystem.
 
@@ -289,8 +289,8 @@ Boot logs go to `~/.legionio/logs/tty-boot.log`.
 
 ```bash
 bundle install
-bundle exec rspec       # 1817 examples, 0 failures
-bundle exec rubocop     # 150 files, 0 offenses
+bundle exec rspec       # 1952 examples, 0 failures
+bundle exec rubocop     # 163 files, 0 offenses
 ```
 
 ## License

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'date'
 require 'resolv'
 require 'shellwords'
 
@@ -185,7 +186,7 @@ module Legion
         # rubocop:enable Metrics/AbcSize
 
         def days_in_month(month, year)
-          Time.new(year, month, -1).day
+          Date.new(year, month, -1).day
         end
 
         def log_result(result, elapsed)

data/lib/legion/tty/daemon_client.rb

@@ -4,6 +4,7 @@ require 'net/http'
 require 'uri'
 require 'fileutils'
 require 'legion/json'
+require 'legion/logging'
 
 module Legion
   module TTY
@@ -12,11 +13,14 @@ module Legion
 
       # rubocop:disable Metrics/ClassLength
       class << self
+        include Legion::Logging::Helper
+
         def configure(daemon_url: 'http://127.0.0.1:4567', cache_file: nil, timeout: 5)
           @daemon_url = daemon_url
           @cache_file = cache_file || File.expand_path('~/.legionio/catalog.json')
           @timeout = timeout
           @manifest = nil
+          log.info { "TTY daemon client configured daemon_url=#{@daemon_url} timeout=#{@timeout}" }
         end
 
         def available?
@@ -26,7 +30,7 @@ module Legion
           end
           response.code.to_i == 200
         rescue StandardError => e
-          Legion::Logging.debug("daemon available? check failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :debug, operation: 'tty.daemon_client.available?', daemon_url: daemon_url)
           false
         end
 
@@ -37,12 +41,9 @@ module Legion
           end
           return nil unless response.code.to_i == 200
 
-          body = Legion::JSON.load(response.body)
-          @manifest = body[:data]
-          write_cache(@manifest)
-          @manifest
+          store_manifest(Legion::JSON.load(response.body)[:data])
         rescue StandardError => e
-          Legion::Logging.warn("fetch_manifest failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'tty.daemon_client.fetch_manifest', daemon_url: daemon_url)
           nil
         end
 
@@ -53,7 +54,7 @@ module Legion
 
           @manifest = Legion::JSON.load(File.read(@cache_file))
         rescue StandardError => e
-          Legion::Logging.warn("cached_manifest failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'tty.daemon_client.cached_manifest', cache_file: @cache_file)
           nil
         end
 
@@ -80,26 +81,28 @@ module Legion
 
           uri = URI("#{daemon_url}/api/llm/chat")
           payload = Legion::JSON.dump({ message: message, model: model, provider: provider })
+          log.debug { "TTY chat request model=#{model} provider=#{provider} message_length=#{message.to_s.length}" }
           response = post_json(uri, payload)
 
           return nil unless response && SUCCESS_CODES.include?(response.code.to_i)
 
           Legion::JSON.load(response.body)
         rescue StandardError => e
-          Legion::Logging.warn("chat failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'tty.daemon_client.chat',
+                              daemon_url: daemon_url, model: model, provider: provider)
           nil
         end
 
         def inference(messages:, tools: [], model: nil, provider: nil, timeout: 120)
+          log.debug { "TTY inference model=#{model} provider=#{provider} msgs=#{Array(messages).size}" }
           response = post_inference(messages: messages, tools: tools, model: model,
                                     provider: provider, timeout: timeout)
           return inference_error_result(response) unless SUCCESS_CODES.include?(response.code.to_i)
 
-          body = Legion::JSON.load(response.body)
-          data = body[:data] || body
-          { status: :ok, data: data }
+          parse_inference_response(response)
         rescue StandardError => e
-          Legion::Logging.warn("inference failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'tty.daemon_client.inference',
+                              daemon_url: daemon_url, model: model, provider: provider, timeout: timeout)
           { status: :unavailable, error: { message: e.message } }
         end
 
@@ -112,6 +115,19 @@ module Legion
 
         private
 
+        def parse_inference_response(response)
+          body = Legion::JSON.load(response.body)
+          data = body[:data] || body
+          { status: :ok, data: data }
+        end
+
+        def store_manifest(data)
+          @manifest = data
+          write_cache(@manifest)
+          log.info { "TTY fetched daemon manifest entries=#{Array(@manifest).size}" }
+          @manifest
+        end
+
         def post_inference(messages:, tools:, model:, provider:, timeout:)
           uri = URI("#{daemon_url}/api/llm/inference")
           payload = Legion::JSON.dump({ messages: messages, tools: tools,
@@ -151,8 +167,9 @@ module Legion
 
           FileUtils.mkdir_p(File.dirname(@cache_file))
           File.write(@cache_file, Legion::JSON.dump(data))
+          log.debug { "TTY daemon manifest cache updated file=#{@cache_file}" }
         rescue StandardError => e
-          Legion::Logging.warn("write_cache failed: #{e.message}") if defined?(Legion::Logging)
+          handle_exception(e, level: :warn, operation: 'tty.daemon_client.write_cache', cache_file: @cache_file)
           nil
         end
       end

data/lib/legion/tty/keybinding_manager.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'legion/json'
+require 'fileutils'
+
+module Legion
+  module TTY
+    # KeybindingManager — context-aware keybinding system with chord support and user customization.
+    #
+    # Named contexts:
+    #   :global, :chat, :dashboard, :extensions, :config, :command_palette, :session_picker, :history
+    #
+    # Chord sequences: two-key combos stored as "key1+key2" strings. Set @pending_chord between
+    # key presses; the second key resolves the chord action.
+    #
+    # User overrides loaded from ~/.legionio/keybindings.json at boot.
+    class KeybindingManager
+      CONTEXTS = %i[global chat dashboard extensions config command_palette session_picker history].freeze
+
+      OVERRIDES_PATH = File.expand_path('~/.legionio/keybindings.json')
+
+      DEFAULT_BINDINGS = {
+        ctrl_d: { contexts: %i[global chat], action: :toggle_dashboard, description: 'Toggle dashboard (Ctrl+D)' },
+        ctrl_k: { contexts: %i[global chat], action: :command_palette, description: 'Open command palette (Ctrl+K)' },
+        ctrl_s: { contexts: %i[global chat], action: :session_picker, description: 'Open session picker (Ctrl+S)' },
+        ctrl_l: { contexts: %i[global chat dashboard], action: :refresh, description: 'Refresh screen (Ctrl+L)' },
+        escape: { contexts: CONTEXTS, action: :back, description: 'Go back / dismiss overlay (Escape)' },
+        tab: { contexts: %i[chat], action: :autocomplete, description: 'Auto-complete (Tab)' },
+        ctrl_c: { contexts: CONTEXTS, action: :interrupt, description: 'Interrupt / quit (Ctrl+C)' }
+      }.freeze
+
+      def initialize(overrides_path: OVERRIDES_PATH)
+        @overrides_path = overrides_path
+        @bindings = {}
+        @pending_chord = nil
+        load_defaults
+        load_user_overrides
+      end
+
+      # Resolve a key press given the currently active contexts.
+      #
+      # @param key [Symbol, String] normalized key (e.g. :ctrl_d, :escape)
+      # @param active_contexts [Array<Symbol>] contexts currently in scope (most specific last)
+      # @return [Symbol, nil] action name, or nil if no binding matches
+      def resolve(key, active_contexts: [:global])
+        key_sym = key.to_s.to_sym
+
+        # Chord resolution: if a chord is pending, try to complete it
+        if @pending_chord
+          chord = :"#{@pending_chord}+#{key_sym}"
+          @pending_chord = nil
+          return action_for(chord, active_contexts)
+        end
+
+        # Check if this key starts a chord
+        if chord_starter?(key_sym)
+          @pending_chord = key_sym
+          return :chord_pending
+        end
+
+        action_for(key_sym, active_contexts)
+      end
+
+      # Cancel any in-progress chord sequence.
+      def cancel_chord
+        @pending_chord = nil
+      end
+
+      # Whether a chord is currently waiting for its second key.
+      def chord_pending?
+        !@pending_chord.nil?
+      end
+
+      # Register or override a single binding.
+      # @param key [Symbol, String] normalized key
+      # @param action [Symbol] action name
+      # @param contexts [Array<Symbol>] applicable contexts (:global means all)
+      # @param description [String]
+      def bind(key, action:, contexts: [:global], description: '')
+        @bindings[key.to_s.to_sym] = { contexts: contexts, action: action, description: description }
+      end
+
+      # Remove a binding.
+      def unbind(key)
+        @bindings.delete(key.to_s.to_sym)
+      end
+
+      # All registered bindings as an array of hashes.
+      def list
+        @bindings.map do |key, b|
+          { key: key, action: b[:action], contexts: b[:contexts], description: b[:description] }
+        end
+      end
+
+      # Reload default bindings (resets user overrides).
+      def load_defaults
+        @bindings = {}
+        DEFAULT_BINDINGS.each do |key, binding|
+          @bindings[key] = binding.dup
+        end
+      end
+
+      # Load user overrides from ~/.legionio/keybindings.json.
+      # File format: { "ctrl_d": { "action": "toggle_dashboard", "contexts": ["global"], "description": "..." } }
+      def load_user_overrides
+        return unless File.exist?(@overrides_path)
+
+        raw = Legion::JSON.parse(File.read(@overrides_path), symbolize_names: true)
+        raw.each { |key, cfg| apply_override(key, cfg) }
+      rescue Legion::JSON::ParseError => e
+        Legion::Logging.warn("keybindings load failed: #{e.message}") if defined?(Legion::Logging)
+      end
+
+      private
+
+      def action_for(key_sym, active_contexts)
+        binding_entry = @bindings[key_sym]
+        return nil unless binding_entry
+
+        binding_contexts = binding_entry[:contexts]
+        return binding_entry[:action] if binding_contexts.include?(:global)
+        return binding_entry[:action] if binding_contexts.intersect?(active_contexts)
+
+        nil
+      end
+
+      def apply_override(key, cfg)
+        return unless cfg.is_a?(Hash) && cfg[:action]
+
+        contexts = Array(cfg[:contexts] || [:global]).map(&:to_sym)
+        @bindings[key.to_s.to_sym] = {
+          contexts: contexts,
+          action: cfg[:action].to_sym,
+          description: cfg[:description].to_s
+        }
+      end
+
+      def chord_starter?(key_sym)
+        @bindings.keys.any? { |k| k.to_s.start_with?("#{key_sym}+") }
+      end
+    end
+  end
+end

data/lib/legion/tty/notify.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    # Notify — OS-level terminal notification dispatcher with auto-detection.
+    #
+    # Auto-detects the terminal environment via TERM_PROGRAM and TERM env vars, then
+    # dispatches notifications using the most appropriate backend:
+    #   - iTerm2:   OSC 9 escape sequence
+    #   - kitty:    kitten notify subprocess
+    #   - Ghostty:  OSC 99 escape sequence
+    #   - Linux:    notify-send subprocess
+    #   - macOS:    osascript subprocess
+    #   - fallback: terminal bell (\a)
+    #
+    # Settings integration (read from Legion::Settings when available):
+    #   notifications.terminal.enabled  (default: true)
+    #   notifications.terminal.backend  (default: 'auto')
+    module Notify
+      BACKENDS = %w[iterm2 kitty ghostty notify_send osascript bell].freeze
+
+      class << self
+        # Send a notification.
+        # @param message [String] notification body
+        # @param title [String] notification title
+        def send(message, title: 'LegionIO')
+          return unless enabled?
+
+          backend = configured_backend
+          dispatch(backend, message: message, title: title)
+        end
+
+        # Detect the current terminal program from environment variables.
+        # @return [String] one of: 'iterm2', 'kitty', 'ghostty', 'linux', 'macos', 'unknown'
+        def detect_terminal
+          term_prog = ::ENV.fetch('TERM_PROGRAM', '').downcase
+          term = ::ENV.fetch('TERM', '').downcase
+
+          return 'iterm2'  if term_prog == 'iterm.app'
+          return 'kitty'   if term_prog == 'kitty' || term == 'xterm-kitty'
+          return 'ghostty' if term_prog == 'ghostty'
+          return 'linux'   if linux?
+          return 'macos'   if macos?
+
+          'unknown'
+        end
+
+        private
+
+        def enabled?
+          return true unless defined?(Legion::Settings)
+
+          setting = settings_dig(:notifications, :terminal, :enabled)
+          setting.nil? || setting
+        end
+
+        def configured_backend
+          backend_setting = settings_dig(:notifications, :terminal, :backend)
+          return resolve_auto_backend if backend_setting.nil? || backend_setting.to_s == 'auto'
+
+          backend_setting.to_s
+        end
+
+        def resolve_auto_backend
+          case detect_terminal
+          when 'iterm2'  then 'iterm2'
+          when 'kitty'   then 'kitty'
+          when 'ghostty' then 'ghostty'
+          when 'linux'   then 'notify_send'
+          when 'macos'   then 'osascript'
+          else 'bell'
+          end
+        end
+
+        def dispatch(backend, message:, title:)
+          case backend.to_s
+          when 'iterm2'      then notify_iterm2(message: message)
+          when 'kitty'       then notify_kitty(message: message, title: title)
+          when 'ghostty'     then notify_ghostty(message: message, title: title)
+          when 'notify_send' then notify_send(message: message, title: title)
+          when 'osascript'   then notify_osascript(message: message, title: title)
+          else notify_bell
+          end
+        rescue StandardError => e
+          Legion::Logging.warn("Notify dispatch failed: #{e.message}") if defined?(Legion::Logging)
+          notify_bell
+        end
+
+        # iTerm2: OSC 9 — "Application-specific notification"
+        def notify_iterm2(message:)
+          $stdout.print("\e]9;#{message}\a")
+          $stdout.flush
+        end
+
+        # Kitty: kitten notify subprocess
+        def notify_kitty(message:, title:)
+          ::Kernel.system('kitten', 'notify', '--title', title, message)
+        end
+
+        # Ghostty: OSC 99 (freedesktop desktop notifications via escape sequence)
+        def notify_ghostty(message:, title:)
+          payload = "i=1:p=body;#{message}\e\\\\#{title}"
+          $stdout.print("\e]99;#{payload}\a")
+          $stdout.flush
+        end
+
+        # Linux: notify-send
+        def notify_send(message:, title:)
+          ::Kernel.system('notify-send', title, message)
+        end
+
+        # macOS: osascript display notification
+        def notify_osascript(message:, title:)
+          script = "display notification #{message.inspect} with title #{title.inspect}"
+          ::Kernel.system('osascript', '-e', script)
+        end
+
+        def notify_bell
+          $stdout.print("\a")
+          $stdout.flush
+        end
+
+        def linux?
+          !macos? && (::ENV.key?('DISPLAY') || ::ENV.key?('WAYLAND_DISPLAY') || RUBY_PLATFORM.include?('linux'))
+        end
+
+        def macos?
+          RUBY_PLATFORM.include?('darwin')
+        end
+
+        def settings_dig(*keys)
+          return nil unless defined?(Legion::Settings)
+
+          first, *rest = keys
+          obj = Legion::Settings[first]
+          rest.reduce(obj) do |acc, key|
+            break nil unless acc.is_a?(Hash)
+
+            acc[key]
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/session_store.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'legion/json'
 require 'fileutils'
 
 module Legion
@@ -21,17 +21,16 @@ module Legion
           saved_at: Time.now.iso8601,
           version: 1
         }
-        File.write(session_path(name), ::JSON.generate(data))
+        File.write(session_path(name), Legion::JSON.generate(data))
       end
 
       def load(name)
         path = session_path(name)
         return nil unless File.exist?(path)
 
-        data = ::JSON.parse(File.read(path), symbolize_names: true)
-        data[:messages] = data[:messages].map { |m| deserialize_message(m) }
-        data
-      rescue ::JSON::ParserError => e
+        data = Legion::JSON.parse(File.read(path), symbolize_names: true)
+        normalize_session(data)
+      rescue Legion::JSON::ParseError => e
         Legion::Logging.warn("session load failed: #{e.message}") if defined?(Legion::Logging)
         nil
       end
@@ -39,7 +38,7 @@ module Legion
       def list
         entries = Dir.glob(File.join(@dir, '*.json')).map do |path|
           name = File.basename(path, '.json')
-          data = ::JSON.parse(File.read(path), symbolize_names: true)
+          data = Legion::JSON.parse(File.read(path), symbolize_names: true)
           { name: name, saved_at: data[:saved_at], message_count: data[:messages]&.size || 0 }
         rescue StandardError => e
           Legion::Logging.warn("session list entry failed: #{e.message}") if defined?(Legion::Logging)
@@ -77,6 +76,25 @@ module Legion
       def deserialize_message(msg)
         { role: msg[:role].to_sym, content: msg[:content], tool_panels: [] }
       end
+
+      # Normalize a loaded session to the canonical TTY format.
+      # Handles two shapes:
+      #   - TTY format (v1): { version: 1, name:, messages: [{role:, content:}], metadata:, saved_at: }
+      #   - CLI format (legacy): { messages: [{role:, content:, model:, stats:, summary:}] }
+      def normalize_session(data)
+        data[:messages] = (data[:messages] || []).map { |m| normalize_message(m) }
+        data[:version] ||= 1
+        data[:metadata] ||= {}
+        data[:name] ||= 'imported'
+        data[:saved_at] ||= Time.now.iso8601
+        data
+      end
+
+      def normalize_message(msg)
+        role = msg[:role].to_s.to_sym
+        content = msg[:content].to_s
+        { role: role, content: content, tool_panels: [] }
+      end
     end
   end
 end

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.40'
+    VERSION = '0.4.42'
   end
 end

data/lib/legion/tty.rb

@@ -4,6 +4,8 @@ require_relative 'tty/version'
 require_relative 'tty/boot_logger'
 require_relative 'tty/theme'
 require_relative 'tty/hotkeys'
+require_relative 'tty/keybinding_manager'
+require_relative 'tty/notify'
 require_relative 'tty/screen_manager'
 require_relative 'tty/screens/base'
 require_relative 'tty/components/digital_rain'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.4.40
+  version: 0.4.42
 platform: ruby
 authors:
 - Esity
@@ -197,14 +197,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.8
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.8
+        version: 1.5.0
 description: Rich TUI with onboarding wizard, AI chat shell, and operational dashboards
   for LegionIO
 email:
@@ -246,6 +246,8 @@ files:
 - lib/legion/tty/components/wizard_prompt.rb
 - lib/legion/tty/daemon_client.rb
 - lib/legion/tty/hotkeys.rb
+- lib/legion/tty/keybinding_manager.rb
+- lib/legion/tty/notify.rb
 - lib/legion/tty/screen_manager.rb
 - lib/legion/tty/screens/base.rb
 - lib/legion/tty/screens/chat.rb