kward 0.82.0 → 0.84.0

data/lib/kward/prompt_interface/editor/word_completion.rb

@@ -0,0 +1,124 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Interactive terminal UI used by the CLI frontend.
+  class PromptInterface
+    # Current-buffer word completion for the built-in composer file editor.
+    module EditorWordCompletion
+      EDITOR_COMPLETION_WORD_PATTERN = /[[:alnum:]_]+/.freeze
+      EDITOR_COMPLETION_PREFIX_PATTERN = /[[:alnum:]_]+\z/.freeze
+      EDITOR_COMPLETION_SUFFIX_PATTERN = /\A[[:alnum:]_]*/.freeze
+
+      private
+
+      def editor_complete_buffer_word
+        if (cycle = matching_editor_completion_cycle)
+          return cycle_editor_word_completion(cycle) if cycle[:candidates].length > 1
+
+          reset_editor_word_completion
+        end
+
+        context = editor_word_completion_context
+        return false unless context
+
+        candidates = editor_word_completion_candidates(context)
+        return false if candidates.empty?
+
+        @editor_word_completion = context.merge(
+          editor_state: @editor_state,
+          candidates: candidates,
+          index: 0,
+          previous_status: @editor_state.status
+        )
+        apply_editor_word_completion(@editor_word_completion)
+        true
+      end
+
+      def editor_word_completion_context
+        buffer = @editor_state.buffer
+        cursor = @editor_state.cursor
+        prefix_match = buffer[0...cursor].to_s.match(EDITOR_COMPLETION_PREFIX_PATTERN)
+        return nil unless prefix_match
+
+        suffix = buffer[cursor..].to_s.match(EDITOR_COMPLETION_SUFFIX_PATTERN).to_s
+        {
+          prefix: prefix_match[0],
+          range_start: prefix_match.begin(0),
+          range_end: cursor + suffix.length
+        }
+      end
+
+      def editor_word_completion_candidates(context)
+        matches = []
+        @editor_state.buffer.to_enum(:scan, EDITOR_COMPLETION_WORD_PATTERN).each do
+          match = Regexp.last_match
+          next if editor_completion_match_overlaps_context?(match, context)
+
+          word = match[0]
+          next unless word.length > context[:prefix].length
+          next unless word.start_with?(context[:prefix])
+
+          matches << [word, match.begin(0)]
+        end
+
+        matches
+          .sort_by { |_word, offset| editor_completion_candidate_order(offset, context) }
+          .map(&:first)
+          .uniq
+      end
+
+      def editor_completion_match_overlaps_context?(match, context)
+        match.begin(0) < context[:range_end] && match.end(0) > context[:range_start]
+      end
+
+      def editor_completion_candidate_order(offset, context)
+        if offset < context[:range_start]
+          [0, context[:range_start] - offset]
+        else
+          [1, offset - context[:range_end]]
+        end
+      end
+
+      def matching_editor_completion_cycle
+        cycle = @editor_word_completion
+        return nil unless cycle
+
+        same_editor = cycle[:editor_state].equal?(@editor_state)
+        same_buffer = cycle[:buffer] == @editor_state.buffer
+        same_cursor = cycle[:cursor] == @editor_state.cursor
+        return cycle if same_editor && same_buffer && same_cursor
+
+        reset_editor_word_completion
+        nil
+      end
+
+      def cycle_editor_word_completion(cycle)
+        cycle[:index] = (cycle[:index] + 1) % cycle[:candidates].length
+        apply_editor_word_completion(cycle)
+        true
+      end
+
+      def apply_editor_word_completion(cycle)
+        candidate = cycle[:candidates][cycle[:index]]
+        @editor_state.replace_range(cycle[:range_start], cycle[:range_end], candidate)
+        @editor_state.cursor = cycle[:range_start] + candidate.length
+        cycle[:range_end] = @editor_state.cursor
+        cycle[:buffer] = @editor_state.buffer
+        cycle[:cursor] = @editor_state.cursor
+        cycle[:status] = "Completion #{cycle[:index] + 1}/#{cycle[:candidates].length}: #{candidate}"
+        @editor_state.status = cycle[:status]
+      end
+
+      def reset_editor_word_completion
+        cycle = @editor_word_completion
+        if cycle && cycle[:editor_state].status == cycle[:status]
+          cycle[:editor_state].status = cycle[:previous_status]
+        end
+        @editor_word_completion = nil
+      end
+
+      def editor_word_completion_tab_key?(key)
+        !editor_tab_sequence_for(key).nil?
+      end
+    end
+  end
+end

data/lib/kward/prompt_interface/file_overlay.rb

@@ -1,3 +1,5 @@
+require_relative "../text_matcher"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # File-mention completion overlay behavior.
@@ -86,36 +88,86 @@ module Kward
       def file_overlay_matches
         token = active_file_open || active_file_mention
         return [] unless token
+        unless @file_mention_paths
+          start_file_mention_discovery_locked
+          return []
+        end
 
         query = token[:query].downcase
+        entries = project_file_path_entries
+        cache = @file_overlay_match_cache
+        return cache[:matches] if cache && cache[:query] == query && cache[:entries].equal?(entries)
+
+        pattern = TextMatcher.subsequence_pattern(query)
         matches = []
-        project_file_path_entries.each do |entry|
-          next unless file_mention_match?(entry[:downcase], query)
+        entries.each do |entry|
+          next unless TextMatcher.subsequence?(entry[:downcase], query, pattern)
 
           matches << entry[:path]
           break if matches.length >= FILE_MENTION_RESULT_LIMIT
         end
+        @file_overlay_match_cache = { query: query, entries: entries, matches: matches }
         matches
       end
 
-      def file_mention_match?(path, query)
-        return true if query.empty?
-        return true if path.include?(query)
-
-        query_chars = query.chars
-        query_chars.all? do |char|
-          index = path.index(char)
-          if index
-            path = path[(index + 1)..].to_s
-            true
-          else
-            false
+      def start_file_mention_discovery_locked
+        root = prompt_workspace_root
+        active_thread = @file_mention_discovery_thread
+        return if active_thread&.alive? && @file_mention_discovery_root == root
+
+        token = Object.new
+        start = Queue.new
+        @file_mention_discovery_root = root
+        @file_mention_discovery_token = token
+        worker = Thread.new do
+          start.pop
+          paths = discover_file_mention_paths(root)
+          entries = build_file_path_entries(paths)
+          @mutex.synchronize do
+            next unless @file_mention_discovery_token.equal?(token)
+
+            @file_mention_discovery_thread = nil
+            @file_mention_discovery_root = nil
+            @file_mention_discovery_token = nil
+            next unless root == prompt_workspace_root
+
+            @file_mention_paths = paths
+            @file_mention_path_entries_paths = paths
+            @file_mention_path_entries = entries
+            @file_overlay_match_cache = nil
+            render_prompt_locked if @started && @asking && file_overlay_visible?
           end
         end
+        worker.report_on_exception = false
+        @file_mention_discovery_thread = worker
+        start << true
+      end
+
+      def discover_file_mention_paths(root)
+        ProjectFiles.list(root: root)
+      end
+
+      def finish_file_mention_discovery_locked
+        root = prompt_workspace_root
+        @file_mention_discovery_thread = nil
+        @file_mention_discovery_root = nil
+        @file_mention_discovery_token = nil
+        @file_mention_paths = discover_file_mention_paths(root)
+        @file_mention_path_entries_paths = @file_mention_paths
+        @file_mention_path_entries = build_file_path_entries(@file_mention_paths)
+        @file_overlay_match_cache = nil
+      end
+
+      def file_mention_discovery_loading?
+        @file_mention_discovery_thread&.alive? && @file_mention_discovery_root == prompt_workspace_root
       end
 
-      def project_file_paths
-        @file_mention_paths ||= discover_project_file_paths
+      def project_file_paths(include_ignored: false)
+        if include_ignored
+          @project_browser_file_paths ||= discover_project_file_paths(include_ignored: true)
+        else
+          @file_mention_paths ||= discover_project_file_paths
+        end
       end
 
       def project_file_path_entries
@@ -123,17 +175,31 @@ module Kward
         return @file_mention_path_entries if @file_mention_path_entries_paths.equal?(paths) && @file_mention_path_entries
 
         @file_mention_path_entries_paths = paths
-        @file_mention_path_entries = paths.map { |path| { path: path, downcase: path.downcase } }
+        @file_mention_path_entries = build_file_path_entries(paths)
+      end
+
+      def build_file_path_entries(paths)
+        paths.map { |path| { path: path, downcase: path.downcase } }
       end
 
-      def discover_project_file_paths
-        paths = git_project_file_paths
-        paths = scanned_project_file_paths if paths.empty?
+      def discover_project_file_paths(include_ignored: false)
+        paths = if include_ignored
+                  git_project_file_paths(include_ignored: true)
+                else
+                  git_project_file_paths
+                end
+        paths = scanned_project_file_paths if paths.empty? && !git_project_repository?
         paths.reject { |path| path.empty? || path.end_with?("/") }.uniq.sort
       end
 
-      def git_project_file_paths
-        ProjectFiles.git_paths(prompt_workspace_root)
+      def git_project_file_paths(include_ignored: false)
+        return ProjectFiles.git_paths(prompt_workspace_root) unless include_ignored
+
+        ProjectFiles.git_paths(prompt_workspace_root, include_ignored: true)
+      end
+
+      def git_project_repository?
+        ProjectFiles.git_repository?(prompt_workspace_root)
       end
 
       def scanned_project_file_paths
@@ -151,6 +217,7 @@ module Kward
       def selected_file_overlay_path
         return nil unless file_overlay_visible?
 
+        finish_file_mention_discovery_locked unless @file_mention_paths
         matches = file_overlay_matches
         return nil if matches.empty?
 
@@ -186,6 +253,9 @@ module Kward
         return [] unless file_overlay_visible?
 
         matches = file_overlay_matches
+        if file_mention_discovery_loading?
+          return overlay_card_rows("Files", [overlay_text_line("Loading project files…", :muted)], width)
+        end
         if matches.empty?
           return overlay_card_rows("Files", [overlay_text_line("No matching files", :muted)], width)
         end

data/lib/kward/prompt_interface/key_handler.rb

@@ -6,6 +6,73 @@ module Kward
     module KeyHandler
       private
 
+      def filter_terminal_handoff_input_locked(chunk)
+        @handoff_input_buffer << chunk.to_s.b
+        forwarded = +"".b
+        tab_action = nil
+
+        until @handoff_input_buffer.empty?
+          if @handoff_input_buffer.start_with?(TerminalKeys::CTRL_T)
+            action = handle_tab_key_binding(TerminalKeys::CTRL_T)
+            if action != false
+              remainder = @handoff_input_buffer.byteslice(TerminalKeys::CTRL_T.bytesize..).to_s
+              queue_pending_keys(remainder) unless remainder.empty?
+              @handoff_input_buffer.clear
+              tab_action = action
+              break
+            end
+            forwarded << @handoff_input_buffer.slice!(0)
+            next
+          end
+
+          if @handoff_input_buffer.start_with?("\e")
+            complete = TerminalKeys::TAB_ACTION_SEQUENCES.find { |sequence| @handoff_input_buffer.start_with?(sequence) }
+            partial = TerminalKeys::TAB_ACTION_SEQUENCES.any? { |sequence| sequence.start_with?(@handoff_input_buffer) }
+            break if partial && !complete
+
+            if complete
+              action = handle_tab_key_binding(complete)
+              if action != false
+                remainder = @handoff_input_buffer.byteslice(complete.bytesize..).to_s
+                queue_pending_keys(remainder) unless remainder.empty?
+                @handoff_input_buffer.clear
+                tab_action = action
+                break
+              end
+              forwarded << complete
+              @handoff_input_buffer = @handoff_input_buffer.byteslice(complete.bytesize..).to_s.b
+              next
+            end
+
+            if (sequence = parse_csi_u_key(@handoff_input_buffer)) && @handoff_input_buffer.start_with?(sequence[:sequence])
+              legacy_key = legacy_handoff_key(sequence)
+              unless legacy_key.nil?
+                forwarded << legacy_key
+                @handoff_input_buffer = @handoff_input_buffer.byteslice(sequence[:sequence].bytesize..).to_s.b
+                next
+              end
+            end
+          end
+
+          forwarded << @handoff_input_buffer.slice!(0)
+        end
+
+        { input: forwarded, tab_action: tab_action }
+      end
+
+      def legacy_handoff_key(sequence)
+        event = csi_u_key_event(sequence)
+        return event[:text] if event[:type] == :printable
+        return "\r" if event[:type] == :enter
+        return "\b" if event[:type] == :backspace
+        return "\t" if event[:type] == :tab
+
+        return unless event[:type] == :modified && ctrl_modifier?(event[:modifier])
+        return unless event[:code].between?(32, 126)
+
+        (event[:code] & 0x1f).chr
+      end
+
       def read_key(nonblock: false)
         pending = @pending_keys.shift unless @pending_keys.empty?
         return pending if pending
@@ -20,6 +87,14 @@ module Kward
       end
 
       def handle_editor_input_key(key)
+        if @editor_agent_suspended
+          return CANCEL_INPUT if @busy && key == TerminalKeys::CTRL_C
+
+          return true
+        end
+
+        reset_editor_word_completion unless editor_word_completion_tab_key?(key)
+
         tab_result = handle_tab_key_binding(key)
         return tab_result unless tab_result == false
 

data/lib/kward/prompt_interface/overlay_renderer.rb

@@ -1,3 +1,5 @@
+require_relative "../terminal_text"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Shared overlay drawing helpers for prompt UI popups.
@@ -63,7 +65,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
+        plain_length = TerminalText.width(ANSI.strip(title))
         colored("╭", :primary_green) + " #{colored(title, :primary_green, :bold)} " + colored("─" * [card_width - plain_length - 4, 0].max, :primary_green) + colored("╮", :primary_green)
       end
 
@@ -98,7 +100,7 @@ module Kward
       end
 
       def align_overlay_row(row, width)
-        plain_length = ANSI.strip(row).length
+        plain_length = TerminalText.width(ANSI.strip(row))
         padding = [width - plain_length, 0].max
         left = overlay_left_padding(width, plain_length)
         right = padding - left
@@ -152,14 +154,14 @@ module Kward
       end
 
       def visible_ljust(text, width)
-        text.to_s + (" " * [width - ANSI.strip(text.to_s).length, 0].max)
+        text.to_s + (" " * [width - TerminalText.width(ANSI.strip(text.to_s)), 0].max)
       end
 
       def visible_truncate(text, width)
         plain = ANSI.strip(text.to_s)
-        return text.to_s if plain.length <= width
+        return text.to_s if TerminalText.width(plain) <= width
 
-        plain[0, width]
+        TerminalText.truncate(plain, width)
       end
 
     end