kward 0.70.0 → 0.72.0

data/lib/kward/prompt_interface/question_prompt.rb

@@ -8,13 +8,7 @@ module Kward
 
       def ask_single_user_question(question, index, total)
         @mutex.synchronize do
-          @prompt_label = "Answer>"
-          self.composer_input = ""
-          self.composer_cursor = 0
-          @pending_keys.clear
-          @asking = true
-          @busy = false
-          @queued_count = 0
+          prepare_modal_input_locked("Answer>")
           @question_state = {
             question: question[:question] || question["question"],
             header: question[:header] || question["header"],
@@ -23,7 +17,6 @@ module Kward
             index: index,
             total: total
           }
-          reset_history_navigation
           render_prompt_locked
         end
 
@@ -37,6 +30,7 @@ module Kward
               render_prompt_locked if resized || footer_refreshed
             else
               result = handle_question_key(key)
+              result = drain_pending_question_keys_locked(result)
               render_prompt_locked unless result.is_a?(Hash) || result == SELECT_CANCEL
             end
           end
@@ -47,6 +41,13 @@ module Kward
         end
       end
 
+      def drain_pending_question_keys_locked(result)
+        until result.is_a?(Hash) || result == SELECT_CANCEL || @pending_keys.empty?
+          result = handle_question_key(@pending_keys.shift)
+        end
+        result
+      end
+
       def begin_question_prompt_state
         {
           prompt_label: @prompt_label,
@@ -64,6 +65,7 @@ module Kward
       def finish_question_prompt(saved_state)
         @mutex.synchronize do
           @question_state = nil
+          @question_prompt_active = false
           @select_state = saved_state[:select_state]
           @prompt_label = saved_state[:prompt_label]
           self.composer_input = saved_state[:input]
@@ -80,20 +82,17 @@ module Kward
 
       def handle_question_key(key)
         return if handle_question_bracketed_paste_key(key)
+        return if handle_question_shift_enter_key(key)
 
         csi_result = handle_question_csi_u_key(key)
         return csi_result unless csi_result == false
 
-        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_question_key(token)
-          end
-        end
+        return true if handle_bundled_key(key) { |token| handle_question_key(token) }
+
+        binding_result = handle_question_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
           current_question_answer
         when :backspace
@@ -101,13 +100,13 @@ module Kward
         when :delete
           question_delete_at_cursor
         when :left
-          self.composer_cursor -= 1 if composer_cursor.positive?
+          move_cursor_left
         when :right
-          self.composer_cursor += 1 if composer_cursor < composer_input.length
+          move_cursor_right
         when :home
-          self.composer_cursor = 0
+          move_to_start_of_line
         when :end
-          self.composer_cursor = composer_input.length
+          move_to_end_of_line
         when :up
           question_previous_choice
         when :down
@@ -127,59 +126,80 @@ module Kward
       end
 
       def handle_question_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
-        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 13
-          current_question_answer
+          if modifier == 2
+            question_insert_string("\n")
+            nil
+          else
+            current_question_answer
+          end
         when 27
           SELECT_CANCEL
         when 8, 127
-          question_delete_before_cursor
+          alt_modifier?(modifier) ? question_delete_word_before_cursor : question_delete_before_cursor
           nil
         else
-          false
+          modified_result = handle_question_modified_csi_u_key(code, modifier)
+          return modified_result unless modified_result == false
+
+          question_insert_csi_u_text(sequence)
         end
       end
 
+      def handle_question_modified_csi_u_key(code, modifier)
+        before = composer_input.dup
+        result = handle_modified_csi_u_key(code, modifier)
+        question_select_custom_choice if result != false && composer_input != before
+        result
+      end
+
+      def question_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
+
+        question_insert_string(text)
+      end
+
       def handle_question_escape_sequence
-        sequence = read_pending_escape_sequence
-        return SELECT_CANCEL if sequence.empty?
+        pending_sequence = read_pending_escape_sequence
+        return SELECT_CANCEL if pending_sequence.empty?
 
-        key_name = @reader.console.keys["\e#{sequence}"]
-        case key_name
+        full_sequence = "\e#{pending_sequence}"
+        sequence = next_key_token(full_sequence)
+        queue_pending_keys(full_sequence[sequence.length..]) if full_sequence.length > sequence.length
+        return SELECT_CANCEL if sequence == "\e"
+
+        binding_result = handle_question_composer_key_binding(sequence)
+        return binding_result unless binding_result == false
+
+        case key_name_for(sequence)
         when :up
           question_previous_choice
         when :down
           question_next_choice
         when :left
-          self.composer_cursor -= 1 if composer_cursor.positive?
+          move_cursor_left
         when :right
-          self.composer_cursor += 1 if composer_cursor < composer_input.length
+          move_cursor_right
         end
         true
       end
 
       def handle_question_bracketed_paste_key(key)
-        text = key.to_s
-        return false unless text.start_with?(BRACKETED_PASTE_START)
-
-        pasted = text[BRACKETED_PASTE_START.length..] || ""
-        until pasted.include?(BRACKETED_PASTE_END)
-          chunk = @reader.read_keypress(echo: false, raw: true)
-          break if chunk.nil?
+        paste = read_bracketed_paste(key)
+        return false unless paste
 
-          pasted << chunk.to_s
-        end
-
-        content, remaining = pasted.split(BRACKETED_PASTE_END, 2)
-        question_insert_string(normalize_paste(content || ""))
-        queue_pending_keys(remaining) if remaining && !remaining.empty?
+        question_insert_string(normalize_paste(paste[:content]))
+        queue_pending_keys(paste[:remaining]) if paste[:remaining] && !paste[:remaining].empty?
         true
       end
 
@@ -248,38 +268,78 @@ module Kward
         question_insert_string(key)
       end
 
+      def handle_question_shift_enter_key(key)
+        sequence = shift_enter_sequence_for(key)
+        return false unless sequence
+
+        question_insert_string("\n")
+        queue_pending_keys(key[sequence.length..]) if key.length > sequence.length
+        true
+      end
+
+      def handle_question_composer_key_binding(key)
+        before = composer_input.dup
+        result = handle_composer_key_binding(key)
+        question_select_custom_choice if result != false && composer_input != before
+        result
+      end
+
       def question_insert_string(string)
         return if string.empty?
 
-        self.composer_input = composer_input[0...composer_cursor] + string + composer_input[composer_cursor..]
-        self.composer_cursor += string.length
-        @question_state[:selection_index] = question_choices.length - 1 if @question_state
+        insert_string(string)
+        question_select_custom_choice
       end
 
       def question_delete_before_cursor
-        return unless composer_cursor.positive?
-
-        self.composer_input = composer_input[0...(composer_cursor - 1)] + composer_input[composer_cursor..]
-        self.composer_cursor -= 1
-        @question_state[:selection_index] = question_choices.length - 1 if @question_state && !composer_input.empty?
+        before = composer_input.dup
+        delete_before_cursor
+        question_select_custom_choice if composer_input != before && !composer_input.empty?
       end
 
       def question_delete_at_cursor
-        return unless composer_cursor < composer_input.length
+        before = composer_input.dup
+        delete_at_cursor
+        question_select_custom_choice if composer_input != before && !composer_input.empty?
+      end
 
-        self.composer_input = composer_input[0...composer_cursor] + composer_input[(composer_cursor + 1)..]
-        @question_state[:selection_index] = question_choices.length - 1 if @question_state && !composer_input.empty?
+      def question_delete_word_before_cursor
+        before = composer_input.dup
+        delete_word_before_cursor
+        question_select_custom_choice if composer_input != before && !composer_input.empty?
+      end
+
+      def question_select_custom_choice
+        @question_state[:selection_index] = question_choices.length - 1 if @question_state
       end
 
       def question_composer_layout(width, height = screen_height)
         content_width = [width - 4, 1].max
         overlay_rows = active_overlay_rows(width, height: height)
-        rows = overlay_rows + [top_border(width), box_content_row("", content_width), bottom_border(width)]
-        return [rows, question_custom_cursor_row, question_custom_cursor_col(width)] if selected_question_choice&.fetch(:custom, false)
+        return question_custom_composer_layout(width, height, overlay_rows, content_width) if selected_question_choice&.fetch(:custom, false)
 
+        rows = overlay_rows + [top_border(width), box_content_row("", content_width)]
+        rows.concat(question_bottom_border_rows(width))
         [rows, overlay_rows.length + 1, 2]
       end
 
+      def question_custom_composer_layout(width, height, overlay_rows, content_width)
+        input_layout_rows, input_cursor_row, input_cursor_col = input_layout(content_width)
+        max_input_rows = max_visible_input_rows(0, overlay_rows.length, 0, height: height)
+        visible_start = [[input_cursor_row - max_input_rows + 1, 0].max, [input_layout_rows.length - max_input_rows, 0].max].min
+        visible_rows = input_layout_rows[visible_start, max_input_rows] || [""]
+        rows = overlay_rows + [top_border(width)]
+        rows.concat(visible_rows.map { |row| box_content_row(row, content_width) })
+        rows.concat(question_bottom_border_rows(width))
+        cursor_row = overlay_rows.length + 1 + input_cursor_row - visible_start
+        cursor_col = 2 + [input_cursor_col, content_width - 1].min
+        [rows, cursor_row, cursor_col]
+      end
+
+      def question_bottom_border_rows(width)
+        @tabs.empty? ? [bottom_border(width)] : tab_border_rows(width)
+      end
+
       def question_overlay_rows(width)
         title = "Question #{@question_state[:index]}/#{@question_state[:total]} · #{@question_state[:header]}"
         lines = [
@@ -294,35 +354,15 @@ module Kward
         overlay_card_rows(title, lines, width)
       end
 
-      def question_custom_cursor_row
-        4 + question_choices.index { |choice| choice[:custom] }.to_i
-      end
-
-      def question_custom_cursor_col(width)
-        card_width = overlay_card_width(width)
-        left_padding = overlay_left_padding(width, card_width)
-        custom_prefix = selected_question_choice&.fetch(:custom, false) || !composer_input.empty? ? "Type something: " : "Type something."
-        visible_before_cursor = display_question_input(composer_input[0...composer_cursor])
-        [[left_padding + 2 + 2 + custom_prefix.length + visible_before_cursor.length, width - 1].min, 0].max
-      end
-
       def choice_text(choice, selected: false)
         if choice[:custom]
-          if selected || !composer_input.empty?
-            "Type something: #{display_question_input(composer_input)}"
-          else
-            "Type something."
-          end
+          selected ? "Type a custom answer below." : "Type something."
         else
           description = choice[:description].empty? ? "" : " — #{choice[:description]}"
           "#{choice[:label]}#{description}"
         end
       end
 
-      def display_question_input(value)
-        value.to_s.gsub(/\s+/, " ")
-      end
-
     end
   end
 end

data/lib/kward/prompt_interface/runtime_state.rb

@@ -17,7 +17,7 @@ module Kward
       end
 
       def tick_spinner_locked
-        return false unless @busy && @queued_count.zero? && @started && @asking
+        return false unless spinner_active?
 
         now = monotonic_now
         elapsed = now - @last_spinner_tick
@@ -33,6 +33,11 @@ module Kward
         SPINNER_FRAMES[@spinner_frame_index % SPINNER_FRAMES.length]
       end
 
+      def spinner_active?
+        busy = @busy || (@select_state && @select_state[:busy_activity])
+        busy && @queued_count.zero? && @started && @asking
+      end
+
       def tick_footer_locked
         return false unless @footer && @started && @asking
 
@@ -45,6 +50,21 @@ module Kward
         true
       end
 
+      def cached_composer_status_text
+        return nil unless @composer_status
+
+        now = monotonic_now
+        elapsed = now - @last_composer_status_refresh.to_f
+        if @cached_composer_status_text.nil? || elapsed >= COMPOSER_STATUS_REFRESH_INTERVAL
+          text = @composer_status.call.to_s
+          @cached_composer_status_text = text.empty? ? nil : status_composer_text(text)
+          @last_composer_status_refresh = now
+        end
+        @cached_composer_status_text
+      rescue StandardError
+        @cached_composer_status_text = nil
+      end
+
       def monotonic_now
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
@@ -54,6 +74,34 @@ module Kward
         ANSI.colorize(text, *styles, enabled: @color_enabled)
       end
 
+      def normalize_tab_keybindings(value)
+        text = value.to_s.downcase
+        return "ctrl" if text == "ctrl"
+        return "alt" if text == "alt"
+
+        RbConfig::CONFIG["host_os"].to_s.downcase.include?("darwin") ? "ctrl" : "alt"
+      end
+
+      def normalize_editor_mode(value)
+        EditorMode.normalize(value)
+      end
+
+      def normalize_editor_line_numbers(value)
+        EditorMode.normalize_line_numbers(value)
+      end
+
+      def tab_action_result?(result)
+        result.is_a?(Hash) && result[:tab_action]
+      end
+
+      def reasoning_action_result?(result)
+        result.is_a?(Hash) && result[:reasoning_action]
+      end
+
+      def prompt_action_result?(result)
+        tab_action_result?(result) || reasoning_action_result?(result)
+      end
+
     end
   end
 end

data/lib/kward/prompt_interface/screen.rb

@@ -55,6 +55,9 @@ module Kward
 
       def render_cursor_visibility_locked
         visible = !(@question_state && !selected_question_choice&.fetch(:custom, false))
+        visible = select_editing_active? if @select_state
+        visible = git_composing? if @git_state
+        visible = project_browser_search_active? if project_browser_visible?
         set_cursor_visible_locked(visible)
       end
 
@@ -65,6 +68,20 @@ module Kward
         @cursor_visible = visible
       end
 
+      def set_editor_bar_cursor_locked
+        return if @editor_bar_cursor_active
+
+        @output_io.print(CURSOR_SHAPE_BAR)
+        @editor_bar_cursor_active = true
+      end
+
+      def restore_editor_cursor_shape_locked
+        return unless @editor_bar_cursor_active
+
+        @output_io.print(CURSOR_SHAPE_DEFAULT)
+        @editor_bar_cursor_active = false
+      end
+
       def reserve_composer_region_locked(width: screen_width, height: screen_height)
         rows, = composer_layout(width, height)
         ensure_scroll_region_locked(rows.length, width: width, height: height)