kward 0.67.0 → 0.68.0

data/lib/kward/prompt_interface/overlay_renderer.rb

@@ -0,0 +1,111 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared overlay drawing helpers for prompt UI popups.
+  class PromptInterface
+    # Renderer for selection, slash-command, and question overlays.
+    module OverlayRenderer
+      private
+
+      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
+
+        slash_overlay_rows(width, height: height)
+      end
+
+      def overlay_card_rows(title, content_rows, width)
+        card_width = overlay_card_width(width)
+        inner_width = [card_width - 4, 1].max
+        rows = [overlay_top_border(title, card_width)]
+        rows.concat(content_rows.map { |row| overlay_content_row(row, inner_width) })
+        rows << overlay_bottom_border(card_width)
+        rows.map { |row| align_overlay_row(row, width) }
+      end
+
+      def overlay_card_width(width)
+        return width if width < 32
+        return width if @overlay_settings["width"] == "maximum"
+
+        [[width - 4, 32].max, 96].min
+      end
+
+      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)
+      end
+
+      def overlay_bottom_border(card_width)
+        colored("╰#{"─" * [card_width - 2, 0].max}╯", :primary_green)
+      end
+
+      def overlay_content_row(row, inner_width)
+        text = visible_truncate(row[:text], inner_width)
+        text = colored(text, :bright_accent_green, :bold) if row[:selected]
+        colored("│", :primary_green) + " " + visible_ljust(text, inner_width) + " " + colored("│", :primary_green)
+      end
+
+      def overlay_text_line(text, style = nil)
+        rendered = case style
+                   when :bold
+                     colored(text.to_s, :bold)
+                   when :muted
+                     colored(text.to_s, :gray)
+                   else
+                     text.to_s
+                   end
+        { text: rendered }
+      end
+
+      def overlay_blank_line
+        { text: "" }
+      end
+
+      def overlay_choice_line(text, selected: false)
+        { text: "#{selected ? "›" : " "} #{text}", selected: selected }
+      end
+
+      def align_overlay_row(row, width)
+        plain_length = ANSI.strip(row).length
+        padding = [width - plain_length, 0].max
+        left = overlay_left_padding(width, plain_length)
+        right = padding - left
+        (" " * left) + row + (" " * right)
+      end
+
+      def overlay_left_padding(width, row_width)
+        padding = [width - row_width, 0].max
+        case @overlay_settings["alignment"]
+        when "left"
+          0
+        when "right"
+          padding
+        else
+          padding / 2
+        end
+      end
+
+      def normalize_overlay_settings(settings)
+        values = { "alignment" => "center", "width" => "capped" }
+        source = settings.is_a?(Hash) ? settings : {}
+        alignment = (source[:alignment] || source["alignment"]).to_s
+        width = (source[:width] || source["width"]).to_s
+        values["alignment"] = alignment if %w[left center right].include?(alignment)
+        values["width"] = width if %w[capped maximum].include?(width)
+        values
+      end
+
+      def visible_ljust(text, width)
+        text.to_s + (" " * [width - ANSI.strip(text.to_s).length, 0].max)
+      end
+
+      def visible_truncate(text, width)
+        plain = ANSI.strip(text.to_s)
+        return text.to_s if plain.length <= width
+
+        plain[0, width]
+      end
+
+    end
+  end
+end

data/lib/kward/prompt_interface/prompt_renderer.rb

@@ -0,0 +1,91 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Prompt label and composer chrome renderer.
+  class PromptInterface
+    # Renderer for prompt labels and composer prompt chrome.
+    module PromptRenderer
+      private
+
+      def render_prompt_locked
+        return unless @started && @asking
+
+        handle_resize_locked
+        width, height = screen_size
+        rows, cursor_row, cursor_col = composer_layout(width, height)
+        ensure_scroll_region_locked(rows.length, width: width, height: height)
+        @rendered_rows = rows.length
+        render_composer_rows_locked(rows, height: height)
+        @cursor_rendered_row = cursor_row
+        @last_width = width
+        @last_height = height
+        move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
+        render_cursor_visibility_locked
+        @output_io.flush
+      end
+
+      def render_prompt_after_output_locked
+        render_prompt_locked
+      end
+
+      def clear_prompt_locked
+        handle_resize_locked
+        width, height = screen_size
+        clear_composer_region_locked(height: height)
+        @rendered_rows = 0
+        @cursor_rendered_row = 0
+        redraw_transcript_locked(width: width, height: height)
+      end
+
+      def clear_prompt_for_output_locked
+        handle_resize_locked
+        width, height = screen_size
+        reserve_composer_region_locked(width: width, height: height) if @started && @asking
+        clear_composer_region_locked(height: height)
+        @rendered_rows = 0
+        @cursor_rendered_row = 0
+        move_to_transcript_cursor_locked(width: width, height: height) if @started
+      end
+
+      def prepare_transcript_output_locked
+        handle_resize_locked
+        width, height = screen_size
+        hide_cursor_for_transcript_output_locked
+        reserve_composer_region_locked(width: width, height: height)
+        move_to_transcript_cursor_locked(width: width, height: height)
+      end
+
+      def restore_composer_cursor_locked
+        return unless @started && @asking
+
+        width, height = screen_size
+        _rows, cursor_row, cursor_col = composer_layout(width, height)
+        move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
+        render_cursor_visibility_locked
+      end
+
+      def redraw_screen_locked(width: screen_width, height: screen_height)
+        return unless @started
+
+        restore_scroll_region_locked
+        @output_io.print(TTY::Cursor.clear_screen)
+        move_to_screen(1, 1)
+        @reserved_rows = 0
+        @last_composer_rows = []
+        rows, cursor_row, cursor_col = composer_layout(width, height)
+        ensure_scroll_region_locked(rows.length, redraw_transcript: false, width: width, height: height)
+        redraw_transcript_locked(width: width, height: height)
+        @rendered_rows = @asking ? rows.length : 0
+        render_composer_rows_locked(rows, height: height) if @asking
+        @cursor_rendered_row = @asking ? cursor_row : 0
+        @last_width = width
+        @last_height = height
+        reset_stream_position_from_transcript_locked(width)
+        if @asking
+          move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
+          render_cursor_visibility_locked
+        end
+      end
+
+    end
+  end
+end

data/lib/kward/prompt_interface/question_prompt.rb

@@ -0,0 +1,328 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Structured question overlay used by ask_user_question.
+  class PromptInterface
+    # Structured question overlay used by the ask-user-question tool.
+    module QuestionPrompt
+      private
+
+      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
+          @question_state = {
+            question: question[:question] || question["question"],
+            header: question[:header] || question["header"],
+            options: question[:options] || question["options"],
+            selection_index: 0,
+            index: index,
+            total: total
+          }
+          reset_history_navigation
+          render_prompt_locked
+        end
+
+        loop do
+          key = read_key(nonblock: true)
+          result = nil
+          @mutex.synchronize do
+            if key.nil?
+              resized = handle_resize_locked
+              footer_refreshed = tick_footer_locked
+              render_prompt_locked if resized || footer_refreshed
+            else
+              result = handle_question_key(key)
+              render_prompt_locked unless result.is_a?(Hash) || result == SELECT_CANCEL
+            end
+          end
+
+          return result if result.is_a?(Hash) || result == SELECT_CANCEL
+
+          sleep 0.02 if key.nil?
+        end
+      end
+
+      def begin_question_prompt_state
+        {
+          prompt_label: @prompt_label,
+          input: composer_input,
+          cursor: composer_cursor,
+          asking: @asking,
+          busy: @busy,
+          queued_count: @queued_count,
+          steered_count: @steered_count,
+          pending_keys: @pending_keys.dup,
+          select_state: @select_state
+        }
+      end
+
+      def finish_question_prompt(saved_state)
+        @mutex.synchronize do
+          @question_state = nil
+          @select_state = saved_state[:select_state]
+          @prompt_label = saved_state[:prompt_label]
+          self.composer_input = saved_state[:input]
+          self.composer_cursor = saved_state[:cursor]
+          @asking = saved_state[:asking]
+          @busy = saved_state[:busy]
+          @queued_count = saved_state[:queued_count]
+          @steered_count = saved_state[:steered_count]
+          @pending_keys = saved_state[:pending_keys]
+          render_prompt_locked if @started && @asking
+          @output_io.flush
+        end
+      end
+
+      def handle_question_key(key)
+        return if handle_question_bracketed_paste_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
+
+        key_name = @reader.console.keys[key]
+        case key_name
+        when :return, :enter
+          current_question_answer
+        when :backspace
+          question_delete_before_cursor
+        when :delete
+          question_delete_at_cursor
+        when :left
+          self.composer_cursor -= 1 if composer_cursor.positive?
+        when :right
+          self.composer_cursor += 1 if composer_cursor < composer_input.length
+        when :home
+          self.composer_cursor = 0
+        when :end
+          self.composer_cursor = composer_input.length
+        when :up
+          question_previous_choice
+        when :down
+          question_next_choice
+        else
+          case key
+          when "\n", "\r"
+            current_question_answer
+          when "\b", "\x7F"
+            question_delete_before_cursor
+          when "\e"
+            handle_question_escape_sequence
+          else
+            question_insert_key(key)
+          end
+        end
+      end
+
+      def handle_question_csi_u_key(key)
+        match = key.to_s.match(/\A\e\[(\d+)(?:;([\d:]+))?u/)
+        return false unless match
+
+        sequence = match[0]
+        code = match[1].to_i
+        queue_pending_keys(key[sequence.length..]) if key.length > sequence.length
+
+        case code
+        when 13
+          current_question_answer
+        when 27
+          SELECT_CANCEL
+        when 8, 127
+          question_delete_before_cursor
+          nil
+        else
+          false
+        end
+      end
+
+      def handle_question_escape_sequence
+        sequence = read_pending_escape_sequence
+        return SELECT_CANCEL if sequence.empty?
+
+        key_name = @reader.console.keys["\e#{sequence}"]
+        case key_name
+        when :up
+          question_previous_choice
+        when :down
+          question_next_choice
+        when :left
+          self.composer_cursor -= 1 if composer_cursor.positive?
+        when :right
+          self.composer_cursor += 1 if composer_cursor < composer_input.length
+        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?
+
+          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?
+        true
+      end
+
+      def current_question_answer
+        choice = selected_question_choice
+        return nil unless choice
+
+        if choice[:custom]
+          answer = composer_input.strip
+          return nil if answer.empty?
+
+          { question: current_question_text, answer: answer, custom: true }
+        else
+          { question: current_question_text, answer: choice[:label], custom: false }
+        end
+      end
+
+      def selected_question_choice
+        choices = question_choices
+        return nil if choices.empty?
+
+        choices[question_selection_index]
+      end
+
+      def question_choices
+        options = Array(@question_state ? @question_state[:options] : []).map do |option|
+          { label: (option[:label] || option["label"]).to_s, description: (option[:description] || option["description"]).to_s }
+        end
+        choices = options + [{ label: "Type something.", description: composer_input.strip, custom: true }]
+        clamp_question_selection_index(choices.length)
+        choices
+      end
+
+      def current_question_text
+        (@question_state && @question_state[:question]).to_s
+      end
+
+      def question_selection_index
+        @question_state ? @question_state[:selection_index].to_i : 0
+      end
+
+      def clamp_question_selection_index(count)
+        return unless @question_state
+
+        @question_state[:selection_index] = 0 if count <= 0
+        @question_state[:selection_index] = count - 1 if count.positive? && question_selection_index >= count
+      end
+
+      def question_previous_choice
+        choices = question_choices
+        return if choices.empty?
+
+        @question_state[:selection_index] = (question_selection_index - 1) % choices.length
+      end
+
+      def question_next_choice
+        choices = question_choices
+        return if choices.empty?
+
+        @question_state[:selection_index] = (question_selection_index + 1) % choices.length
+      end
+
+      def question_insert_key(key)
+        return unless key.is_a?(String) && key.length == 1 && key.match?(/[[:print:]]/)
+
+        question_insert_string(key)
+      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
+      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?
+      end
+
+      def question_delete_at_cursor
+        return unless composer_cursor < composer_input.length
+
+        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?
+      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)
+
+        [rows, overlay_rows.length + 1, 2]
+      end
+
+      def question_overlay_rows(width)
+        title = "Question #{@question_state[:index]}/#{@question_state[:total]} · #{@question_state[:header]}"
+        lines = [
+          overlay_text_line(@question_state[:question].to_s, :bold),
+          overlay_text_line("↑/↓ select · Enter choose · Esc cancel", :muted),
+          overlay_blank_line
+        ]
+        question_choices.each_with_index do |choice, index|
+          selected = index == question_selection_index
+          lines << overlay_choice_line(choice_text(choice, selected: selected), selected: selected)
+        end
+        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
+        else
+          description = choice[:description].empty? ? "" : " — #{choice[:description]}"
+          "#{choice[:label]}#{description}"
+        end
+      end
+
+      def display_question_input(value)
+        value.to_s.gsub(/\s+/, " ").strip
+      end
+
+    end
+  end
+end

data/lib/kward/prompt_interface/runtime_state.rb

@@ -0,0 +1,59 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Runtime metadata shown in the prompt footer and status UI.
+  class PromptInterface
+    # Runtime footer, model, persona, and session state shown by the prompt interface.
+    module RuntimeState
+      private
+
+      def reset_spinner_locked
+        @spinner_frame_index = 0
+        @last_spinner_tick = monotonic_now
+      end
+
+      def normalize_busy_activity(activity)
+        text = activity.to_s.gsub(/\s+/, " ").strip
+        text.empty? ? "streaming" : text
+      end
+
+      def tick_spinner_locked
+        return false unless @busy && @queued_count.zero? && @started && @asking
+
+        now = monotonic_now
+        elapsed = now - @last_spinner_tick
+        return false if elapsed < SPINNER_INTERVAL
+
+        steps = (elapsed / SPINNER_INTERVAL).floor
+        @spinner_frame_index = (@spinner_frame_index + steps) % SPINNER_FRAMES.length
+        @last_spinner_tick += steps * SPINNER_INTERVAL
+        true
+      end
+
+      def spinner_frame
+        SPINNER_FRAMES[@spinner_frame_index % SPINNER_FRAMES.length]
+      end
+
+      def tick_footer_locked
+        return false unless @footer && @started && @asking
+
+        now = monotonic_now
+        elapsed = now - @last_footer_refresh
+        return false if elapsed < FOOTER_REFRESH_INTERVAL
+
+        steps = (elapsed / FOOTER_REFRESH_INTERVAL).floor
+        @last_footer_refresh += steps * FOOTER_REFRESH_INTERVAL
+        true
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+
+      def colored(text, *styles)
+        ANSI.colorize(text, *styles, enabled: @color_enabled)
+      end
+
+    end
+  end
+end