legion-tty 0.4.40 → 0.4.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60e92790f0f6281b48346af3972e2631f1952b3b68f3d51922aa52da8682cfc9
-  data.tar.gz: 85491c70182ced9142b483c4edd903f3e5948bac1544c01cba69a86f565d2483
+  metadata.gz: 2e5ecb9de86922a5a3d4dd3b3eca6b4f7864103c89399a8a945bbae95e749814
+  data.tar.gz: 0d25f75d79303fd7a42a9fbf125768503c48f16e5c749b799cd2013d68bae99a
 SHA512:
-  metadata.gz: 757d74c3e7e0d7711cc9bb0cb410c145e7e8ca31d484d62ad53160df64c34205be19d6eb0fa91d7aede125af63ff1d005f596ea10c285fcbdc97adb5c74eee19
-  data.tar.gz: df6acc61f03cfc4631ccd28eaea40813314aadc8211497e857507ac7453ab700952bf6588a4d34016d3d5196651680583a293ff1bfba204101408b62a5c7fd4d
+  metadata.gz: 804bc560650b61a6987a8f9d4d02cd7a315caeaccd1823f1b11a4e1b1fe024fc0eb37a35c59bafe654c0738f2e201af9b04d7274bd9c7d8df02b563c6551336b
+  data.tar.gz: 15ab28737a1677ae28285400d1e9ae6b794f1ea021e4cc7c194e949e59a97df56c054419d21fd351c70ea97636608d09a8a6737ca7a690e17b398e87531e6c1c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [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/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.41'
   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.41
 platform: ruby
 authors:
 - Esity
@@ -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