kward 0.83.0 → 0.84.0

data/lib/kward/project_files.rb

@@ -15,13 +15,13 @@ module Kward
     end
 
     def git_paths(root, include_ignored: false)
-      output, status = Open3.capture2("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
+      output, status = Open3.capture2e("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
       return [] unless status.success?
 
       paths = output.lines.map(&:chomp).reject(&:empty?)
       return paths unless include_ignored
 
-      ignored_output, ignored_status = Open3.capture2("git", "ls-files", "--others", "--ignored", "--exclude-standard", chdir: root)
+      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?)

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.
@@ -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

@@ -145,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
@@ -179,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
 
@@ -187,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
 
@@ -195,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)
@@ -248,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
@@ -410,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)
@@ -425,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
@@ -477,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
@@ -513,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
@@ -532,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
 
@@ -544,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

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

@@ -1,5 +1,6 @@
 require "fileutils"
-require_relative "../../scratchpad_runner"
+require_relative "../../scratchpad_languages"
+require_relative "runner"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -243,8 +244,13 @@ module Kward
       end
 
       def close_editor
+        cancel_editor_runner
         disable_editor_mouse_reporting(force: true)
         restore_editor_cursor_shape_locked
+        @editor_runner_state = nil
+        @editor_runner_completion = nil
+        @editor_runner_output_visible = false
+        clear_editor_runner_selection
         @editor_text_width = nil
         @editor_save_as_active = false
         @editor_save_as_buffer = ""
@@ -261,12 +267,16 @@ module Kward
       def handle_editor_key(key)
         return if key.nil?
         return handle_editor_prompt_key(key) if @editor_prompt_active
+        return handle_editor_runner_output_key(key) if editor_runner_output_visible?
 
         reset_editor_word_completion unless editor_word_completion_tab_key?(key) && !editor_search_active?
         mouse_result = handle_editor_mouse_key(key)
         return mouse_result unless mouse_result == false
         return handle_editor_save_as_key(key) if @editor_save_as_active
         return handle_readonly_editor_key(key) if @editor_state&.readonly?
+        return cancel_editor_runner if editor_runner_running? && @editor_runner_completion && key == TerminalKeys::CTRL_C
+        super_copy_result = handle_editor_super_copy_key(key)
+        return super_copy_result unless super_copy_result == false
         return handle_vibe_key(key) if @editor_state&.vibe?
         return handle_emacs_key(key) if @editor_state&.emacs?
         return handle_modern_key(key) if @editor_state&.modern?
@@ -323,6 +333,22 @@ module Kward
         end
       end
 
+      def handle_editor_super_copy_key(key)
+        sequence = parse_csi_u_key(key)
+        return false unless sequence
+        return false unless super_modifier?(sequence[:modifier]) && ctrl_code(sequence[:code]) == 99
+
+        queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
+        return editor_search_cancel if editor_search_active?
+        return false unless editor_selection_active?
+
+        if @editor_state.vibe? && vibe_visual_mode?
+          vibe_yank_visual_selection
+        else
+          copy_editor_selection
+        end
+      end
+
       def editor_prompt_action(instruction)
         {
           editor_prompt: {
@@ -1387,45 +1413,16 @@ module Kward
         true
       end
 
-      def run_editor_buffer
-        return false unless @editor_state
-
-        language = @editor_state.language || editor_syntax_language
-        result = ScratchpadRunner.run(language, @editor_state.buffer)
-        @editor_state.replace_range(0, @editor_state.buffer.length, result.buffer)
-        @editor_state.status = "Ran #{language} (exit #{result.exit_status})"
-        true
-      rescue StandardError => e
-        @editor_state.status = "Run failed: #{e.message}" if @editor_state
-        false
-      end
-
       def normalize_scratchpad_language(language)
-        case language.to_s.strip.downcase
-        when "", "text", "txt"
-          :text
-        when "markdown", "md"
-          :markdown
-        when "ruby", "rb"
-          :ruby
-        else
-          :text
-        end
+        ScratchpadLanguages.normalize(language)
       end
 
       def scratchpad_display_path(language)
-        case language.to_sym
-        when :markdown
-          "scratchpad.md"
-        when :ruby
-          "scratchpad.rb"
-        else
-          "scratchpad.txt"
-        end
+        ScratchpadLanguages.display_path(language)
       end
 
       def scratchpad_status_text(language)
-        runnable = language.to_sym == :ruby
+        runnable = ScratchpadLanguages.runnable?(language)
         case current_editor_mode
         when "vibe"
           runnable ? "NORMAL · i insert · :w filename save · :q quit · :run run" : "NORMAL · i insert · :w filename save · :q quit"

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

@@ -136,7 +136,7 @@ module Kward
         line_index, column = @editor_state.cursor_line_and_column
         return nil unless editor_endwise_line_exists?(line_index)
 
-        language = editor_syntax_language
+        language = editor_effective_syntax_language(line_index)
         definition = ENDWISE_LANGUAGES[language]
         return nil unless definition
 
@@ -190,7 +190,8 @@ module Kward
         line_index >= 0 && line_index < @editor_state.lines.length
       end
 
-      def editor_endwise_line_opens_block?(line_index, language = editor_syntax_language)
+      def editor_endwise_line_opens_block?(line_index, language = nil)
+        language ||= editor_effective_syntax_language(line_index)
         code = editor_endwise_code_line_at(line_index, language)
         return false if editor_endwise_ignored_definition?(code, language)
 
@@ -200,7 +201,7 @@ module Kward
       end
 
       def editor_endwise_closing_keyword_for_line(line_index, column, called_with_modifier: false)
-        language = editor_syntax_language
+        language = editor_effective_syntax_language(line_index)
         definition = ENDWISE_LANGUAGES[language]
         return nil unless definition
 
@@ -221,6 +222,9 @@ module Kward
             return close if @editor_state.lines.length <= scan_line + 1
 
             line_below = @editor_state.lines[scan_line + 1].to_s
+            next_language = editor_effective_syntax_language(scan_line + 1)
+            return close if next_language != language
+
             code_below = editor_endwise_code_line_at(scan_line + 1, language)
             closes_any_block = editor_endwise_closes_block?(code_below, language)
             closes_this_block = editor_endwise_closes_with?(code_below, close)
@@ -254,6 +258,8 @@ module Kward
       end
 
       def editor_endwise_code_line_at(line_index, language)
+        return "" unless editor_effective_syntax_language(line_index) == language
+
         definition = ENDWISE_LANGUAGES[language]
         line = @editor_state.lines[line_index].to_s
         return "" if editor_endwise_inside_block_comment?(line_index, definition.fetch(:block_comments))
@@ -263,7 +269,10 @@ module Kward
 
       def editor_endwise_inside_block_comment?(line_index, block_comments)
         active_comment = nil
-        @editor_state.lines.first(line_index + 1).each_with_index do |line, index|
+        first_index = editor_syntax_context_start(line_index)
+        first_index = 0 unless first_index
+        (first_index..line_index).each do |index|
+          line = @editor_state.lines[index].to_s
           if active_comment
             target_line = index == line_index
             active_comment = nil if line.match?(active_comment.fetch(:end))