kward 0.82.0 → 0.84.0

data/lib/kward/project_files.rb

@@ -8,21 +8,34 @@ module Kward
   module ProjectFiles
     module_function
 
-    def list(root: Dir.pwd)
-      paths = git_paths(root)
-      paths = scanned_paths(root) if paths.empty?
+    def list(root: Dir.pwd, include_ignored: false)
+      paths = git_paths(root, include_ignored: include_ignored)
+      paths = scanned_paths(root) if paths.empty? && !git_repository?(root)
       paths.reject { |path| path.empty? || path.end_with?("/") }.uniq.sort
     end
 
-    def git_paths(root)
-      output, status = Open3.capture2("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
+    def git_paths(root, include_ignored: false)
+      output, status = Open3.capture2e("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
       return [] unless status.success?
 
-      output.lines.map(&:chomp).reject(&:empty?)
+      paths = output.lines.map(&:chomp).reject(&:empty?)
+      return paths unless include_ignored
+
+      ignored_output, ignored_status = Open3.capture2e("git", "ls-files", "--others", "--ignored", "--exclude-standard", chdir: root)
+      return paths unless ignored_status.success?
+
+      paths + ignored_output.lines.map(&:chomp).reject(&:empty?)
     rescue StandardError
       []
     end
 
+    def git_repository?(root)
+      _output, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: root)
+      status.success?
+    rescue StandardError
+      false
+    end
+
     def scanned_paths(root)
       root_path = Pathname.new(root)
       paths = []

data/lib/kward/prompt_interface/composer_renderer.rb

@@ -1,3 +1,5 @@
+require_relative "../terminal_text"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Renderer for the editable composer text area.
@@ -8,7 +10,7 @@ module Kward
 
       def composer_layout(width, height = screen_height)
         return interactive_layout(width, height) if interactive_active_locked?
-        return editor_layout(width, height) if editor_active?
+        return editor_layout(width, height) if editor_visible?
         return compact_composer_layout(width) if height < 4
         return question_composer_layout(width, height) if @question_state
 
@@ -35,45 +37,42 @@ module Kward
       end
 
       def compact_composer_layout(width)
-        cursor_line, cursor_col = cursor_logical_position
+        lines, cursor_line, cursor_col = @composer.lines_and_cursor
         prefix = "#{@prompt_label} "
-        line = input_lines[cursor_line] || ""
-        input_width = [width - prefix.length, 1].max
-        visible_start = [[cursor_col - input_width + 1, 0].max, [line.length - input_width, 0].max].min
-        visible = line[visible_start, input_width].to_s
-        row = "#{prefix}#{visible}"[0, width].to_s.ljust(width)
-        [[row], 0, [prefix.length + cursor_col - visible_start, width - 1].min]
+        prefix_width = TerminalText.width(prefix)
+        line = lines[cursor_line] || ""
+        input_width = [width - prefix_width, 1].max
+        layout = TerminalText.wrap(line, width: input_width, cursor: cursor_col)
+        visible = layout[:rows][layout[:cursor_row]].to_s
+        row = visible_ljust(TerminalText.truncate("#{prefix}#{visible}", width), width)
+        [[row], 0, [prefix_width + layout[:cursor_col], width - 1].min]
       end
 
       def input_layout(content_width)
-        cursor_line, cursor_col = cursor_logical_position
+        lines, cursor_line, cursor_col = @composer.lines_and_cursor
         rows = []
         cursor_row = 0
+        cursor_col_in_row = 0
         rendered_row_offset = 0
 
-        input_lines.each_with_index do |line, index|
+        lines.each_with_index do |line, index|
           prefix = input_prefix(index)
-          continuation_prefix = " " * prefix.length
-          available = [content_width - prefix.length, 1].max
-          chunks = line.scan(/.{1,#{available}}/m)
-          chunks = [""] if chunks.empty?
-          if index == cursor_line && cursor_col == line.length && line.length.positive? && (line.length % available).zero?
-            chunks << ""
-          end
+          prefix_width = TerminalText.width(prefix)
+          continuation_prefix = " " * prefix_width
+          available = [content_width - prefix_width, 1].max
+          layout = TerminalText.wrap(line, width: available, cursor: index == cursor_line ? cursor_col : nil)
 
           if index == cursor_line
-            cursor_row = rendered_row_offset + (cursor_col / available)
+            cursor_row = rendered_row_offset + layout[:cursor_row]
+            cursor_col_in_row = prefix_width + layout[:cursor_col]
           end
 
-          chunks.each_with_index do |chunk, chunk_index|
+          layout[:rows].each_with_index do |chunk, chunk_index|
             rows << "#{chunk_index.zero? ? prefix : continuation_prefix}#{chunk}"
           end
-          rendered_row_offset += chunks.length
+          rendered_row_offset += layout[:rows].length
         end
 
-        prefix = input_prefix(cursor_line)
-        available = [content_width - prefix.length, 1].max
-        cursor_col_in_row = prefix.length + (cursor_col % available)
         [rows, cursor_row, cursor_col_in_row]
       end
 
@@ -81,23 +80,28 @@ module Kward
         title = composer_title
         status = cached_composer_status_text
         if status
-          gap = width - 2 - ANSI.strip(title).length - ANSI.strip(status).length
+          gap = width - 2 - TerminalText.width(ANSI.strip(title)) - TerminalText.width(ANSI.strip(status))
           if gap >= 0
             return colored("╭", :primary_green) + title + colored("─" * gap, :primary_green) + status + colored("╮", :primary_green)
           end
         end
         plain_title = ANSI.strip(title)
-        "#{colored("╭", :primary_green)}#{title}#{colored("─" * [width - plain_title.length - 2, 0].max, :primary_green)}#{colored("╮", :primary_green)}"
+        "#{colored("╭", :primary_green)}#{title}#{colored("─" * [width - TerminalText.width(plain_title) - 2, 0].max, :primary_green)}#{colored("╮", :primary_green)}"
       end
 
       def composer_title
         label = composer_title_label
         if @busy && @queued_count.positive?
-          status_composer_text(busy_title("#{label} · #{@queued_count} queued"))
+          status_composer_text(busy_title("#{label} · #{colored("#{@queued_count} queued", :metadata)}"))
         elsif @busy && @steered_count.to_i.positive?
-          status_composer_text(busy_title("#{label} · #{spinner_frame} steering"))
+          status_composer_text(busy_title("#{label} · #{colored(spinner_frame, :activity, :bold)} steering"))
+        elsif @busy && response_arriving?
+          status_composer_text(busy_title("#{label} · #{colored("✦", :activity, :bold)} responding"))
         elsif @busy
-          status_composer_text(busy_title("#{label} · #{spinner_frame} #{@busy_activity}"))
+          status_composer_text(busy_title("#{label} · #{colored(spinner_frame, :activity, :bold)} #{@busy_activity}"))
+        elsif @completion_status
+          completion = colored(@completion_status[:text], @completion_status[:style], :bold)
+          status_composer_text("#{label} · #{completion}")
         else
           status_composer_text(label)
         end
@@ -110,6 +114,8 @@ module Kward
       end
 
       def busy_title(text)
+        elapsed = busy_elapsed_text
+        text = "#{text} · #{colored(elapsed, :metadata)}" if elapsed
         @busy_help ? "#{text} · #{BUSY_HELP_TEXT}" : text
       end
 
@@ -140,7 +146,7 @@ module Kward
         label_left = 4
         @tabs.each_with_index.map do |label, index|
           text = tab_label(label, index)
-          width = ANSI.strip(text).length
+          width = TerminalText.width(ANSI.strip(text))
           slot = {
             left: label_left - 2,
             label_left: label_left,
@@ -185,18 +191,25 @@ module Kward
 
         visible_offset = 0
         last_index = nil
-        text.to_s.scan(/\e\[[0-9;:]*m|./m).each do |part|
+        text.to_s.scan(/\e\[[0-9;:]*m|\X/m).each do |part|
           if part.start_with?("\e")
             index = visible_offset.positive? ? last_index : left
             row[index] = row[index].to_s + part if index&.between?(0, row.length - 1)
             next
           end
 
+          part_width = TerminalText.width(part)
+          if part_width.zero?
+            row[last_index] = row[last_index].to_s + part if last_index
+            next
+          end
+
           index = left + visible_offset
           break if index >= row.length
           row[index] = row[index].to_s.sub(/\A /, "") + part unless index.negative?
+          1.upto(part_width - 1) { |offset| row[index + offset] = "" if (index + offset).between?(0, row.length - 1) }
           last_index = index
-          visible_offset += 1
+          visible_offset += part_width
         end
       end
 
@@ -252,19 +265,10 @@ module Kward
         [[input_cap, height - 3 - overlay_count - footer_count - attachment_count].min, 1].max
       end
 
-      def input_lines
-        lines = composer_input.split("\n", -1)
-        lines.empty? ? [""] : lines
-      end
-
       def input_prefix(_index)
         ""
       end
 
-      def cursor_logical_position
-        @composer.cursor_logical_position
-      end
-
       def image_viewer_preview_rows(height, width: screen_width)
         available_rows = max_project_browser_rows(height, width: width)
         desired_rows = [(IMAGE_VIEWER_MAX_ROWS * image_viewer_zoom).round, 1].max
@@ -276,7 +280,7 @@ module Kward
         preview_rows = image_viewer_preview_rows(height, width: width)
         title = visible_truncate(" Image: #{@image_viewer_state[:display_path]} ", content_width)
         rows = [
-          colored("╭", :primary_green) + title + colored("─" * [width - ANSI.strip(title).length - 2, 0].max, :primary_green) + colored("╮", :primary_green),
+          colored("╭", :primary_green) + title + colored("─" * [width - TerminalText.width(ANSI.strip(title)) - 2, 0].max, :primary_green) + colored("╮", :primary_green),
           image_viewer_graphic_row(width, image_viewer_sequence(width, height))
         ]
         rows.concat(Array.new(preview_rows - 1) { box_content_row("", content_width) })

data/lib/kward/prompt_interface/composer_state.rb

@@ -1,4 +1,6 @@
 require_relative "../text_boundary"
+require_relative "../text_matcher"
+require_relative "../terminal_text"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -41,6 +43,8 @@ module Kward
         @history_search_query = nil
         @history_search_draft = nil
         @history_search_index = 0
+        @history_search_matches_query = nil
+        @history_search_matches = nil
       end
 
       # Removes all pending attachments without changing text input.
@@ -76,31 +80,33 @@ module Kward
         @cursor += string.length
       end
 
-      # Deletes one character before the cursor.
+      # Deletes one grapheme before the cursor.
       def delete_before_cursor
         return false if @cursor.zero?
 
-        @input = @input[0...(@cursor - 1)] + @input[@cursor..]
-        @cursor -= 1
+        previous = TerminalText.previous_grapheme_boundary(@input, @cursor)
+        @input = @input[0...previous] + @input[@cursor..]
+        @cursor = previous
         true
       end
 
-      # Deletes one character at the cursor without moving it.
+      # Deletes one grapheme at the cursor without moving it.
       def delete_at_cursor
         return false unless @cursor < @input.length
 
-        @input = @input[0...@cursor] + @input[(@cursor + 1)..]
+        following = TerminalText.next_grapheme_boundary(@input, @cursor)
+        @input = @input[0...@cursor] + @input[following..]
         true
       end
 
-      # Moves the cursor one character left when possible.
+      # Moves the cursor one grapheme left when possible.
       def move_cursor_left
-        @cursor -= 1 if @cursor.positive?
+        @cursor = TerminalText.previous_grapheme_boundary(@input, @cursor) if @cursor.positive?
       end
 
-      # Moves the cursor one character right when possible.
+      # Moves the cursor one grapheme right when possible.
       def move_cursor_right
-        @cursor += 1 if @cursor < @input.length
+        @cursor = TerminalText.next_grapheme_boundary(@input, @cursor) if @cursor < @input.length
       end
 
       # Moves the cursor to the beginning of the input buffer.
@@ -164,10 +170,14 @@ module Kward
         @cursor = @input.length
       end
 
-      # Returns `[row, column]` for cursor placement in multi-line input.
-      def cursor_logical_position
+      # Returns `[lines, row, column]` for cursor-aware multi-line layout.
+      def lines_and_cursor
+        lines = @input.split("\n", -1)
         before_cursor = @input[0...@cursor]
-        [before_cursor.count("\n"), (before_cursor.split("\n", -1).last || "").length]
+        row = before_cursor.count("\n")
+        line_start = before_cursor.rindex("\n")
+        column = line_start ? before_cursor.length - line_start - 1 : before_cursor.length
+        [lines.empty? ? [""] : lines, row, column]
       end
 
       # Replaces the in-memory history list with persisted entries.
@@ -175,6 +185,7 @@ module Kward
         @history = Array(values).map(&:to_s).reject { |value| value.strip.empty? }
         reset_history_navigation
         reset_history_search
+        invalidate_history_search_matches
       end
 
       # Stores a submitted input unless it is blank or duplicates the previous entry.
@@ -184,6 +195,7 @@ module Kward
         return false if @history.last == value
 
         @history << value
+        invalidate_history_search_matches
         true
       end
 
@@ -234,9 +246,13 @@ module Kward
 
       def history_search_matches
         query = @history_search_query.to_s.downcase
-        return @history.reverse if query.empty?
+        return @history_search_matches if @history_search_matches_query == query && @history_search_matches
 
-        @history.reverse.select { |value| fuzzy_history_match?(value.downcase, query) }
+        pattern = TextMatcher.subsequence_pattern(query)
+        @history_search_matches_query = query
+        @history_search_matches = @history.reverse.select do |value|
+          TextMatcher.subsequence?(value.downcase, query, pattern)
+        end
       end
 
       def selected_history_search_match
@@ -274,16 +290,9 @@ module Kward
         @history_search_index = 0
       end
 
-      def fuzzy_history_match?(value, query)
-        query.chars.all? do |char|
-          index = value.index(char)
-          if index
-            value = value[(index + 1)..].to_s
-            true
-          else
-            false
-          end
-        end
+      def invalidate_history_search_matches
+        @history_search_matches_query = nil
+        @history_search_matches = nil
       end
     end
   end

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

@@ -83,9 +83,12 @@ module Kward
 
       def editor_insert_tab
         if @editor_state.multi_cursor? || @editor_state.selection_ranges.any?
+          reset_editor_word_completion
           return @editor_state.replace_selections(editor_indent_unit)
         end
 
+        return true if editor_complete_buffer_word
+
         if current_editor_auto_indent? && editor_cursor_in_leading_indent?
           return editor_smart_tab_forward
         end
@@ -142,7 +145,7 @@ module Kward
         line = @editor_state.lines[line_index].to_s
         before_cursor = line[0...column].to_s
         base_indent = line[/\A[ \t]*/].to_s
-        language = editor_syntax_language
+        language = editor_effective_syntax_language(line_index)
         indent = base_indent.dup
         indent += editor_indent_unit if editor_line_opens_indent?(before_cursor, language)
         indent
@@ -176,7 +179,8 @@ module Kward
 
       def editor_expected_indent_for_line(line_index)
         line = @editor_state.lines[line_index].to_s
-        code = editor_indent_code(line, editor_syntax_language).strip
+        language = editor_effective_syntax_language(line_index)
+        code = editor_indent_code(line, language).strip
         matching_indent = editor_matching_indent_for_line(code, line_index)
         return matching_indent if matching_indent
 
@@ -184,7 +188,7 @@ module Kward
         return "" unless previous_line
 
         indent = previous_line[:indent].dup
-        indent += editor_indent_unit if editor_line_opens_indent?(previous_line[:code], editor_syntax_language)
+        indent += editor_indent_unit if editor_line_opens_indent?(previous_line[:code], previous_line[:language])
         indent
       end
 
@@ -192,18 +196,12 @@ module Kward
         return nil if code.empty?
         return editor_matching_punctuation_indent(code[0], line_index) if editor_closing_punctuation?(code[0])
 
-        editor_matching_word_indent(line_index) if editor_completed_word_closer?(code, editor_syntax_language)
+        language = editor_effective_syntax_language(line_index)
+        editor_matching_word_indent(line_index) if editor_completed_word_closer?(code, language)
       end
 
       def previous_non_blank_editor_line(line_index)
-        (line_index.to_i - 1).downto(0) do |index|
-          line = @editor_state.lines[index].to_s
-          code = editor_indent_code(line, editor_syntax_language).rstrip
-          next if code.strip.empty?
-
-          return { indent: line[/\A[ \t]*/].to_s, code: code }
-        end
-        nil
+        editor_previous_code_lines(line_index).last
       end
 
       def editor_update_current_line_indent(indent, preserve_content_column: false)
@@ -245,7 +243,7 @@ module Kward
         line = @editor_state.lines[line_index].to_s
         before_cursor = line[0...column].to_s
         base_indent = line[/\A[ \t]*/].to_s
-        language = editor_syntax_language
+        language = editor_effective_syntax_language(line_index)
         opens_indent = editor_line_opens_indent?(before_cursor, language)
         paired_closer = editor_next_paired_closer
         return nil unless paired_closer
@@ -407,7 +405,8 @@ module Kward
       end
 
       def editor_closing_punctuation?(text)
-        PUNCTUATION_PAIRS.key?(text) && PUNCTUATION_INDENT_LANGUAGES.include?(editor_syntax_language)
+        line_index = @editor_state.cursor_line_and_column.first
+        PUNCTUATION_PAIRS.key?(text) && PUNCTUATION_INDENT_LANGUAGES.include?(editor_effective_syntax_language(line_index))
       end
 
       def editor_reindent_for_closing_punctuation(text)
@@ -422,7 +421,7 @@ module Kward
         line_index, column = @editor_state.cursor_line_and_column
         line = @editor_state.lines[line_index].to_s
         before_cursor = line[0...column].to_s
-        return unless editor_completed_word_closer?(before_cursor, editor_syntax_language)
+        return unless editor_completed_word_closer?(before_cursor, editor_effective_syntax_language(line_index))
 
         indent = editor_matching_word_indent(line_index)
         editor_reindent_current_line(indent) if indent
@@ -474,7 +473,8 @@ module Kward
       end
 
       def editor_matching_word_indent(line_index = nil)
-        case editor_syntax_language
+        line_index ||= @editor_state.cursor_line_and_column.first
+        case editor_effective_syntax_language(line_index)
         when :ruby
           editor_matching_keyword_indent("end", %w[end], line_index)
         when :lua
@@ -510,7 +510,7 @@ module Kward
           next if code.empty?
 
           stack.pop if editor_word_closer_line?(code, closers)
-          stack << line[:indent] if editor_word_opener_line?(code, opener)
+          stack << line[:indent] if editor_word_opener_line?(code, opener, line[:language])
         end
         stack.last || ""
       end
@@ -529,11 +529,16 @@ module Kward
 
       def editor_previous_code_lines(line_index = nil)
         line_index ||= @editor_state.cursor_line_and_column.first
-        @editor_state.lines.first(line_index).filter_map do |line|
-          code = editor_indent_code(line, editor_syntax_language).rstrip
+        language = editor_effective_syntax_language(line_index)
+        first_index = editor_syntax_context_start(line_index)
+        first_index = 0 unless first_index && language != :markdown
+
+        (first_index...line_index).filter_map do |index|
+          line = @editor_state.lines[index].to_s
+          code = editor_indent_code(line, language).rstrip
           next if code.strip.empty?
 
-          { indent: line[/\A[ \t]*/].to_s, code: code }
+          { indent: line[/\A[ \t]*/].to_s, code: code, language: language }
         end
       end
 
@@ -541,8 +546,8 @@ module Kward
         code.to_s.scan(/[{}\[\]()]/)
       end
 
-      def editor_word_opener_line?(code, opener)
-        case editor_syntax_language
+      def editor_word_opener_line?(code, opener, language)
+        case language
         when :ruby
           editor_ruby_line_opens_indent?(code)
         when :lua