kward 0.70.0 → 0.72.0

data/lib/kward/prompt_interface/key_handler.rb

@@ -10,6 +10,8 @@ module Kward
         pending = @pending_keys.shift unless @pending_keys.empty?
         return pending if pending
 
+        return nil if nonblock && @input_io.respond_to?(:wait_readable) && !@input_io.wait_readable(0)
+
         @reader.read_keypress(echo: false, raw: true, nonblock: nonblock)
       rescue TTY::Reader::InputInterrupt
         "\x03"
@@ -17,28 +19,43 @@ module Kward
         nil
       end
 
+      def handle_editor_input_key(key)
+        tab_result = handle_tab_key_binding(key)
+        return tab_result unless tab_result == false
+
+        result = handle_editor_key(key)
+        result.is_a?(String) ? true : result
+      end
+
       def handle_key(key)
         return submit_input if key.nil?
+        return handle_interactive_key(key) if interactive_active_locked?
+        return handle_editor_input_key(key) if editor_active?
+        return handle_project_browser_key(key) if project_browser_visible?
+        return handle_history_search_key(key) if history_search_active?
+        return true if handle_mouse_reporting_key(key)
         return if handle_bracketed_paste_key(key)
 
         csi_result = handle_csi_u_key(key)
         return csi_result unless csi_result == false
         return if handle_shift_enter_key(key)
-        if key.is_a?(String) && key.length > 1
-          token = next_key_token(key)
-          if token.length < key.length
-            queue_pending_keys(key[token.length..])
-            return handle_key(token)
-          end
-        end
+        return true if handle_bundled_key(key) { |token| handle_key(token) }
+
+        completion_result = handle_completion_provider_key(key)
+        return completion_result unless completion_result == false
+
+        reasoning_result = handle_reasoning_key_binding(key)
+        return reasoning_result unless reasoning_result == false
+
+        tab_result = handle_tab_key_binding(key)
+        return tab_result unless tab_result == false
 
         binding_result = handle_composer_key_binding(key)
         return binding_result unless binding_result == false
 
-        key_name = @reader.console.keys[key]
-        case key_name
+        case key_name_for(key)
         when :return, :enter
-          submit_input
+          file_open_overlay_visible? ? open_selected_file_in_editor(fallback_to_typed_path: true) : submit_input
         when :backspace
           delete_before_cursor
         when :delete
@@ -65,6 +82,8 @@ module Kward
           yank_kill_buffer
         when :ctrl_l
           redraw_screen_locked
+        when :ctrl_r
+          start_history_search
         when :left
           move_cursor_left
         when :right
@@ -74,21 +93,35 @@ module Kward
         when :end
           move_to_end_of_line
         when :up
-          slash_overlay_visible? ? select_previous_slash_command : recall_previous_history
+          if file_overlay_visible?
+            select_previous_file_mention
+          elsif slash_overlay_visible?
+            select_previous_slash_command
+          else
+            recall_previous_history
+          end
         when :down
-          slash_overlay_visible? ? select_next_slash_command : recall_next_history
+          if file_overlay_visible?
+            select_next_file_mention
+          elsif slash_overlay_visible?
+            select_next_slash_command
+          else
+            recall_next_history
+          end
         else
           case key
           when "\n", "\r"
-            submit_input
+            file_open_overlay_visible? ? open_selected_file_in_editor(fallback_to_typed_path: true) : submit_input
           when "\t"
-            complete_selected_slash_command || insert_key(key)
+            handle_tab_completion_key
           when "\b", "\x7F"
             delete_before_cursor
           when "\x04"
             delete_at_cursor_or_exit
           when "\x03"
             cancel_input_or_interrupt
+          when "\x12"
+            start_history_search
           when "\e"
             handle_escape_sequence
           else
@@ -97,31 +130,114 @@ module Kward
         end
       end
 
+      def handle_history_search_key(key)
+        csi_result = handle_history_search_csi_u_key(key)
+        return csi_result unless csi_result == false
+        return true if handle_bundled_key(key) { |token| handle_history_search_key(token) }
+
+        case key_name_for(key)
+        when :return, :enter
+          accept_history_search
+        when :up
+          select_previous_history_search_match
+        when :down
+          select_next_history_search_match
+        when :backspace
+          update_history_search_query(composer_input[0...-1].to_s)
+        when :ctrl_c
+          cancel_history_search
+        else
+          case key
+          when "\n", "\r"
+            accept_history_search
+          when "\b", "\x7F"
+            update_history_search_query(composer_input[0...-1].to_s)
+          when "\x03", "\e"
+            cancel_history_search
+          else
+            append_history_search_key(key)
+          end
+        end
+        true
+      end
+
+      def handle_history_search_csi_u_key(key)
+        sequence = parse_csi_u_key(key)
+        return false unless sequence
+
+        code = sequence[:code]
+        modifier = sequence[:modifier]
+        queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
+
+        if ctrl_modifier?(modifier) && ctrl_code_for(code) == 99
+          cancel_history_search
+        elsif code == 13
+          accept_history_search
+        elsif code == 27
+          cancel_history_search
+        elsif code == 8 || code == 127
+          update_history_search_query(composer_input[0...-1].to_s)
+        else
+          text = csi_u_printable_text(sequence)
+          update_history_search_query(composer_input + text) if text
+        end
+        true
+      end
+
+      def append_history_search_key(key)
+        return unless key.is_a?(String) && key.length == 1 && key.match?(/[[:print:]]/)
+
+        update_history_search_query(composer_input + key)
+      end
+
       def cancel_input_or_interrupt
         return CANCEL_INPUT if @busy
 
         raise Interrupt
       end
 
+      def handle_tab_completion_key
+        open_selected_file_in_editor || complete_selected_file_mention || complete_selected_slash_command || insert_key("\t")
+      end
+
       def handle_escape_sequence
         pending_sequence = read_pending_escape_sequence
-        return true if pending_sequence.empty? && dismiss_slash_overlay
+        return true if pending_sequence.empty? && (dismiss_file_overlay || dismiss_slash_overlay)
 
         full_sequence = "\e#{pending_sequence}"
+        return true if handle_mouse_reporting_key(full_sequence)
+
         sequence = next_key_token(full_sequence)
         queue_pending_keys(full_sequence[sequence.length..]) if full_sequence.length > sequence.length
-        return true if sequence == "\e" && dismiss_slash_overlay
+        return true if sequence == "\e" && (dismiss_file_overlay || dismiss_slash_overlay)
         return true if handle_shift_enter_key(sequence)
 
+        reasoning_result = handle_reasoning_key_binding(sequence)
+        return reasoning_result unless reasoning_result == false
+
+        tab_result = handle_tab_key_binding(sequence)
+        return tab_result unless tab_result == false
+
         binding_result = handle_composer_key_binding(sequence)
         return binding_result unless binding_result == false
 
-        key_name = @reader.console.keys[sequence]
-        case key_name
+        case key_name_for(sequence)
         when :up
-          slash_overlay_visible? ? select_previous_slash_command : recall_previous_history
+          if file_overlay_visible?
+            select_previous_file_mention
+          elsif slash_overlay_visible?
+            select_previous_slash_command
+          else
+            recall_previous_history
+          end
         when :down
-          slash_overlay_visible? ? select_next_slash_command : recall_next_history
+          if file_overlay_visible?
+            select_next_file_mention
+          elsif slash_overlay_visible?
+            select_next_slash_command
+          else
+            recall_next_history
+          end
         when :left
           move_cursor_left
         when :right
@@ -137,8 +253,26 @@ module Kward
       end
 
       def handle_bracketed_paste_key(key)
+        paste = read_bracketed_paste(key)
+        return false unless paste
+
+        insert_paste(normalize_paste(paste[:content]))
+        queue_pending_keys(paste[:remaining]) if paste[:remaining] && !paste[:remaining].empty?
+        true
+      end
+
+      def handle_mouse_reporting_key(key)
+        text = key.to_s
+        match = text.match(/\A(?:\e)?\[<\d+;\d+;\d+[Mm]/)
+        return false unless match
+
+        queue_pending_keys(text[match[0].length..]) if match[0].length < text.length
+        true
+      end
+
+      def read_bracketed_paste(key)
         text = key.to_s
-        return false unless text.start_with?(BRACKETED_PASTE_START)
+        return nil unless text.start_with?(BRACKETED_PASTE_START)
 
         pasted = text[BRACKETED_PASTE_START.length..] || ""
         until pasted.include?(BRACKETED_PASTE_END)
@@ -149,9 +283,7 @@ module Kward
         end
 
         content, remaining = pasted.split(BRACKETED_PASTE_END, 2)
-        insert_paste(normalize_paste(content || ""))
-        queue_pending_keys(remaining) if remaining && !remaining.empty?
-        true
+        { content: content || "", remaining: remaining }
       end
 
       def normalize_paste(content)
@@ -159,33 +291,101 @@ module Kward
       end
 
       def handle_csi_u_key(key)
-        match = key.to_s.match(/\A\e\[(\d+)(?:;([\d:]+))?u/)
-        return false unless match
+        sequence = parse_csi_u_key(key)
+        return false unless sequence
 
-        sequence = match[0]
-        code = match[1].to_i
-        modifier = (match[2] || "1").split(":", 2).first.to_i
-        queue_pending_keys(key[sequence.length..]) if key.length > sequence.length
+        code = sequence[:code]
+        modifier = sequence[:modifier]
+        queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
 
         case code
+        when 9
+          if ctrl_modifier?(modifier)
+            shift_modifier?(modifier) ? { tab_action: :previous } : { tab_action: :next }
+          elsif shift_modifier?(modifier)
+            handle_reasoning_key_binding(key) || handle_tab_completion_key
+          else
+            completion_result = handle_completion_provider_key("\t")
+            completion_result == false ? handle_reasoning_key_binding("\t") || handle_tab_completion_key : completion_result
+          end
         when 13
-          modifier == 2 ? insert_string("\n") : submit_input
+          if modifier == 2
+            insert_string("\n")
+          elsif file_open_overlay_visible?
+            open_selected_file_in_editor(fallback_to_typed_path: true)
+          else
+            submit_input
+          end
         when 27
-          dismiss_slash_overlay || false
+          dismiss_file_overlay || dismiss_slash_overlay || false
         when 8, 127
           alt_modifier?(modifier) ? delete_word_before_cursor : delete_before_cursor
           nil
         when 4
           delete_at_cursor_or_exit
         else
-          handle_modified_csi_u_key(code, modifier)
+          handle_modified_csi_u_key(code, modifier) || insert_csi_u_text(sequence)
         end
       end
 
+      def parse_csi_u_key(key)
+        match = key.to_s.match(/\A\e\[(\d+)((?:;[\d:]*)*)u/)
+        return nil unless match
+
+        fields = match[2].to_s.split(";", -1)[1..] || []
+        modifiers = fields[0].to_s
+        modifier = (modifiers.empty? ? "1" : modifiers).split(":", 2).first.to_i
+        {
+          sequence: match[0],
+          code: match[1].to_i,
+          modifiers: modifiers,
+          modifier: modifier,
+          text: fields[1].to_s,
+          remaining: key.to_s[match[0].length..]
+        }
+      end
+
+      def insert_csi_u_text(sequence)
+        text = csi_u_printable_text(sequence)
+        return true if text.nil? && csi_u_text_field?(sequence)
+        return false unless text
+
+        insert_string(text)
+      end
+
+      def csi_u_text_field?(sequence)
+        !sequence[:text].to_s.empty?
+      end
+
+      def csi_u_printable_text(sequence)
+        text = csi_u_text(sequence)
+        return text unless text.empty?
+        return nil if csi_u_text_field?(sequence)
+        return nil if ctrl_modifier?(sequence[:modifier]) || alt_modifier?(sequence[:modifier]) || super_modifier?(sequence[:modifier])
+        return nil unless sequence[:code].between?(32, 126)
+
+        sequence[:code].chr(Encoding::UTF_8)
+      end
+
+      def csi_u_text(sequence)
+        sequence[:text].to_s.split(":").map do |codepoint|
+          character = csi_u_codepoint_character(codepoint)
+          return "" unless character
+
+          character
+        end.join
+      end
+
+      def csi_u_codepoint_character(codepoint)
+        codepoint.to_i.chr(Encoding::UTF_8)
+      rescue RangeError
+        nil
+      end
+
       def handle_modified_csi_u_key(code, modifier)
         return false unless ctrl_modifier?(modifier) || alt_modifier?(modifier)
 
-        normalized_code = code.to_i.chr.downcase.ord rescue code
+        normalized_code = ctrl_code_for(code)
         if ctrl_modifier?(modifier)
           case normalized_code
           when 97
@@ -206,6 +406,8 @@ module Kward
             kill_line_after_cursor
           when 108
             redraw_screen_locked
+          when 114
+            start_history_search
           when 117
             kill_line_before_cursor
           when 119
@@ -231,6 +433,32 @@ module Kward
         end
       end
 
+      def ctrl_code_for(code)
+        code.to_i.chr.downcase.ord rescue code
+      end
+
+      def key_name_for(key)
+        cursor_key_name(key) || @reader.console.keys[key]
+      end
+
+      def cursor_key_name(key)
+        text = key.to_s
+        case text
+        when /\A\e\[[0-9;:]*A\z/, "\eOA"
+          :up
+        when /\A\e\[[0-9;:]*B\z/, "\eOB"
+          :down
+        when /\A\e\[[0-9;:]*C\z/, "\eOC"
+          :right
+        when /\A\e\[[0-9;:]*D\z/, "\eOD"
+          :left
+        when "\e[5~"
+          :pageup
+        when "\e[6~"
+          :pagedown
+        end
+      end
+
       def ctrl_modifier?(modifier)
         ((modifier.to_i - 1) & 4).positive?
       end
@@ -239,6 +467,14 @@ module Kward
         ((modifier.to_i - 1) & 2).positive?
       end
 
+      def super_modifier?(modifier)
+        ((modifier.to_i - 1) & 8).positive?
+      end
+
+      def shift_modifier?(modifier)
+        ((modifier.to_i - 1) & 1).positive?
+      end
+
       def handle_shift_enter_key(key)
         sequence = shift_enter_sequence_for(key)
         return false unless sequence
@@ -257,6 +493,17 @@ module Kward
         end
       end
 
+      def handle_bundled_key(key)
+        return false unless key.is_a?(String) && key.length > 1
+
+        token = next_key_token(key)
+        return false unless token.length < key.length
+
+        queue_pending_keys(key[token.length..])
+        yield token
+        true
+      end
+
       def next_key_token(keys)
         text = keys.to_s
         text.match(/\A\e\[[0-9;:]*[A-Za-z~]/)&.[](0) ||
@@ -267,7 +514,7 @@ module Kward
 
       def alt_key_sequence?(char)
         char = char.to_s
-        char.match?(/[[:alpha:]]/) || char == "\b" || char == "\x7F"
+        char.match?(/[[:alnum:]]/) || char == "\b" || char == "\x7F"
       end
 
       def shift_enter_sequence_for(key)
@@ -289,6 +536,123 @@ module Kward
         sequence
       end
 
+      CTRL_TAB_SEQUENCES = ["\e[9;5u", "\e[27;5;9~", "\e[1;5I"].freeze
+      CTRL_SHIFT_TAB_SEQUENCES = ["\e[9;6u", "\e[27;6;9~", "\e[1;6I", "\e[1;6Z"].freeze
+      SHIFT_TAB_SEQUENCES = ["\e[Z", "\e[1;2Z", "\e[9;2u", "\e[27;2;9~", "\e[1;2I"].freeze
+
+      def handle_completion_provider_key(key)
+        return false unless key == "\t" && @completion_provider
+
+        result = @completion_provider.call(composer_input, composer_cursor)
+        return true unless result
+
+        apply_completion_result(result)
+        true
+      end
+
+      def apply_completion_result(result)
+        range = result[:range] || result["range"] || result.range
+        replacement = result[:replacement] || result["replacement"] || result.replacement
+        candidates = result[:candidates] || result["candidates"] || result.candidates
+        original = composer_input
+        before = original[0...range.begin].to_s
+        after = original[range.end..].to_s
+        self.composer_input = "#{before}#{replacement}#{after}"
+        self.composer_cursor = before.length + replacement.to_s.length
+        show_completion_candidates(candidates, replacement) if candidates.to_a.length > 1 && replacement.to_s == original[range]
+      end
+
+      def show_completion_candidates(candidates, replacement)
+        lines = candidates.to_a.first(40)
+        text = ["completions:", *lines.map { |candidate| "  #{candidate}" }].join("\n")
+        write_completion_transcript_locked(text)
+      end
+
+      def write_completion_transcript_locked(text)
+        with_synchronized_output_locked do
+          clear_prompt_for_output_locked
+          write_transcript_text_locked("\n#{text}\n")
+          render_prompt_after_output_locked
+        end
+      end
+
+      def handle_reasoning_key_binding(key)
+        return false if @busy || @select_state || @question_state
+        return false if file_overlay_visible? || slash_overlay_visible?
+        return false if @slash_overlay_dismissed_input && @slash_overlay_dismissed_input == composer_input
+        mention_token = active_file_mention_token
+        open_token = active_file_open_token
+        return false if mention_token && @file_overlay_dismissed_token == mention_token
+        return false if open_token && @file_open_dismissed_token == open_token
+
+        case key
+        when "\t"
+          { reasoning_action: :next }
+        when *SHIFT_TAB_SEQUENCES
+          { reasoning_action: :previous }
+        else
+          false
+        end
+      end
+
+      def handle_tab_key_binding(key)
+        return false if @select_state || @question_state || @tabs.empty?
+
+        navigation_result = handle_ctrl_tab_navigation_key_binding(key)
+        return navigation_result unless navigation_result == false
+
+        @tab_keybindings == "ctrl" ? handle_ctrl_tab_key_binding(key) : handle_alt_tab_key_binding(key)
+      end
+
+      def handle_ctrl_tab_navigation_key_binding(key)
+        case key
+        when *CTRL_TAB_SEQUENCES
+          { tab_action: :next }
+        when *CTRL_SHIFT_TAB_SEQUENCES
+          { tab_action: :previous }
+        else
+          false
+        end
+      end
+
+      def handle_ctrl_tab_key_binding(key)
+        case key
+        when "\x14", "\e[116;5u"
+          { tab_action: :new }
+        when "\e[119;5u"
+          { tab_action: :close }
+        else
+          ctrl_number_tab_action(key)
+        end
+      end
+
+      def ctrl_number_tab_action(key)
+        match = key.to_s.match(/\A\e\[((?:49)|(?:5[0-7]));5u\z/)
+        return false unless match
+
+        { tab_action: :select, index: match[1].to_i - 49 }
+      end
+
+      def handle_alt_tab_key_binding(key)
+        case key
+        when "\et", "\eT"
+          { tab_action: :new }
+        when "\e[1;3C", "\e[3C"
+          { tab_action: :next }
+        when "\e[1;3D", "\e[3D"
+          { tab_action: :previous }
+        else
+          alt_number_tab_action(key)
+        end
+      end
+
+      def alt_number_tab_action(key)
+        match = key.to_s.match(/\A\e([1-9])\z/)
+        return false unless match
+
+        { tab_action: :select, index: match[1].to_i - 1 }
+      end
+
       def handle_composer_key_binding(key)
         case key
         when "\x01"
@@ -334,14 +698,23 @@ module Kward
         end
       end
 
+      def parse_modified_ansi_key(key)
+        if (match = key.to_s.match(/\A\e\[(\d+);(\d+)([CDFH])\z/))
+          { type: :cursor, modifier: match[2].to_i, final: match[3] }
+        elsif (match = key.to_s.match(/\A\e\[3;(\d+)~\z/))
+          { type: :delete, modifier: match[1].to_i }
+        end
+      end
+
       def handle_modified_ansi_key(key)
-        match = key.to_s.match(/\A\e\[(\d+);(\d+)([CDFH])\z/)
-        if match
-          modifier = match[2].to_i
-          final = match[3]
-          return false unless alt_modifier?(modifier)
+        sequence = parse_modified_ansi_key(key)
+        return false unless sequence
+
+        case sequence[:type]
+        when :cursor
+          return false unless alt_modifier?(sequence[:modifier])
 
-          case final
+          case sequence[:final]
           when "C"
             move_to_next_word
           when "D"
@@ -353,8 +726,8 @@ module Kward
           else
             false
           end
-        elsif (match = key.to_s.match(/\A\e\[3;(\d+)~\z/))
-          alt_modifier?(match[1].to_i) ? delete_word_after_cursor : delete_at_cursor
+        when :delete
+          alt_modifier?(sequence[:modifier]) ? delete_word_after_cursor : delete_at_cursor
         else
           false
         end

data/lib/kward/prompt_interface/layout.rb

@@ -6,8 +6,8 @@ module Kward
     module Layout
       private
 
-      def banner_rows(width)
-        @banner.rows(width)
+      def banner_rows(width, message: nil)
+        @banner.rows(width, message: message)
       end
 
       def banner_logo_rows

data/lib/kward/prompt_interface/overlay_renderer.rb

@@ -9,10 +9,29 @@ module Kward
       def active_overlay_rows(width, height: screen_height)
         return question_overlay_rows(width) if @question_state
         return selection_overlay_rows(width, height: height) if @select_state
+        return git_overlay_rows(width, height: height) if @git_state
+        return project_browser_rows(width, height: height) if project_browser_visible?
+        return history_search_overlay_rows(width, height: height) if history_search_active?
+        return file_overlay_rows(width, height: height) if file_overlay_visible?
 
         slash_overlay_rows(width, height: height)
       end
 
+      def history_search_overlay_rows(width, height: screen_height)
+        matches = history_search_matches
+        if matches.empty?
+          return overlay_card_rows("History", [overlay_text_line("No matching history", :muted)], width)
+        end
+
+        max_rows = max_overlay_list_rows(height)
+        selected = @composer.history_search_index
+        start = centered_list_window_start(selected, matches.length, max_rows)
+        rows = (matches[start, max_rows] || []).each_with_index.map do |value, offset|
+          overlay_choice_line(value, selected: start + offset == selected)
+        end
+        overlay_card_rows("History", rows, width)
+      end
+
       def overlay_card_rows(title, content_rows, width)
         card_width = overlay_card_width(width)
         inner_width = [card_width - 4, 1].max
@@ -32,7 +51,7 @@ module Kward
       def overlay_top_border(title, card_width)
         title = visible_truncate(title.to_s, [card_width - 4, 1].max)
         plain_length = ANSI.strip(title).length
-        colored("╭", :primary_green) + " #{colored(title, :bright_accent_green, :bold)} " + colored("─" * [card_width - plain_length - 4, 0].max, :primary_green) + colored("╮", :primary_green)
+        colored("╭", :primary_green) + " #{colored(title, :primary_green, :bold)} " + colored("─" * [card_width - plain_length - 4, 0].max, :primary_green) + colored("╮", :primary_green)
       end
 
       def overlay_bottom_border(card_width)
@@ -41,7 +60,7 @@ module Kward
 
       def overlay_content_row(row, inner_width)
         text = visible_truncate(row[:text], inner_width)
-        text = colored(text, :bright_accent_green, :bold) if row[:selected]
+        text = colored(text, :primary_green, :bold) if row[:selected]
         colored("│", :primary_green) + " " + visible_ljust(text, inner_width) + " " + colored("│", :primary_green)
       end