kward 0.79.0 → 0.80.1

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

@@ -323,6 +323,8 @@ module Kward
           code.match?(/:\s*(?:[#].*)?\z/)
         when :html
           editor_html_line_opens_indent?(code)
+        when :erb
+          editor_erb_line_opens_indent?(code)
         when *C_LIKE_INDENT_LANGUAGES
           false
         else
@@ -364,6 +366,46 @@ module Kward
         true
       end
 
+      def editor_erb_line_opens_indent?(code)
+        segments, = editor_erb_segments(code.to_s, :template)
+        segments.any? do |kind, text|
+          case kind
+          when :ruby
+            editor_ruby_line_opens_indent?(text.strip)
+          when :template
+            editor_html_line_opens_indent?(text.strip)
+          else
+            false
+          end
+        end
+      end
+
+      def editor_erb_line_closer?(code)
+        segments, = editor_erb_segments(code.to_s, :template)
+        segments.any? do |kind, text|
+          case kind
+          when :ruby
+            text.strip.match?(/\Aend\z/)
+          when :template
+            text.strip.match?(/\A<\/[A-Za-z][\w:-]*>\z/)
+          else
+            false
+          end
+        end
+      end
+
+      def editor_matching_erb_indent(line_index = nil)
+        stack = []
+        editor_previous_code_lines(line_index).each do |line|
+          code = line[:code].strip
+          next if code.empty?
+
+          stack.pop if editor_erb_line_closer?(code)
+          stack << line[:indent] if editor_erb_line_opens_indent?(code)
+        end
+        stack.last || ""
+      end
+
       def editor_closing_punctuation?(text)
         PUNCTUATION_PAIRS.key?(text) && PUNCTUATION_INDENT_LANGUAGES.include?(editor_syntax_language)
       end
@@ -424,6 +466,8 @@ module Kward
           code.match?(/\A[ \t]*(?:#{Regexp.union(SHELL_DEDENT_KEYWORDS)})\z/)
         when :html
           code.match?(/\A[ \t]*<\/[A-Za-z][\w:-]*>\z/)
+        when :erb
+          editor_erb_line_closer?(code)
         else
           false
         end
@@ -439,6 +483,8 @@ module Kward
           editor_matching_keyword_indent(nil, SHELL_DEDENT_KEYWORDS, line_index)
         when :html
           editor_matching_html_indent(line_index)
+        when :erb
+          editor_matching_erb_indent(line_index)
         end
       end
 

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

@@ -47,20 +47,22 @@ module Kward
       end
 
       def line_and_column_for(offset)
-        before_cursor = before(offset)
-        [before_cursor.count("\n"), (before_cursor.split("\n", -1).last || "").length]
+        offset = [[offset.to_i, 0].max, @text.length].min
+        next_line = line_start_offsets.bsearch_index { |line_offset| line_offset > offset }
+        line_index = next_line ? [next_line - 1, 0].max : lines.length - 1
+        [line_index, [offset - line_start_offsets[line_index], lines[line_index].length].min]
       end
 
       def offset_for_line_and_column(line_index, column)
         values = lines
         line_index = [[line_index.to_i, 0].max, values.length - 1].min
         column = [[column.to_i, 0].max, values[line_index].length].min
-        values.first(line_index).sum { |line| line.length + 1 } + column
+        line_start_offsets[line_index] + column
       end
 
       def line_start_offset(line_index)
         line_index = [[line_index.to_i, 0].max, lines.length - 1].min
-        lines.first(line_index).sum { |line| line.length + 1 }
+        line_start_offsets[line_index]
       end
 
       def line_range(line_index)
@@ -101,8 +103,20 @@ module Kward
 
       private
 
+      def line_start_offsets
+        @line_start_offsets ||= begin
+          values = lines
+          offsets = [0]
+          (values.length - 1).times do |index|
+            offsets << offsets.last + values[index].length + 1
+          end
+          offsets
+        end
+      end
+
       def invalidate_lines_cache
         @lines_cache = nil
+        @line_start_offsets = nil
       end
     end
   end

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

@@ -39,8 +39,8 @@ module Kward
       end
 
       def history_file_open_command(path)
-        full_path = File.expand_path(path.to_s, Dir.pwd)
-        relative_path = Pathname.new(full_path).relative_path_from(Pathname.new(File.expand_path(Dir.pwd))).to_s
+        full_path = File.expand_path(path.to_s, prompt_workspace_root)
+        relative_path = Pathname.new(full_path).relative_path_from(Pathname.new(prompt_workspace_root)).to_s
         "$#{relative_path}"
       rescue ArgumentError
         "$#{path}"
@@ -71,9 +71,9 @@ module Kward
         true
       end
 
-      def open_editor(path, allow_new: false, base_dir: Dir.pwd, restrict_to_workspace: true)
-        full_path = File.expand_path(path.to_s, base_dir)
-        root = File.expand_path(Dir.pwd)
+      def open_editor(path, allow_new: false, base_dir: nil, restrict_to_workspace: true)
+        full_path = File.expand_path(path.to_s, base_dir || prompt_workspace_root)
+        root = prompt_workspace_root
         if restrict_to_workspace && !(full_path == root || full_path.start_with?("#{root}/"))
           @file_editor_open_status = "Cannot edit file outside workspace"
           return false
@@ -1301,8 +1301,8 @@ module Kward
       end
 
       def bind_editor_save_path(path)
-        full_path = File.expand_path(path.to_s.strip, Dir.pwd)
-        root = File.expand_path(Dir.pwd)
+        full_path = File.expand_path(path.to_s.strip, prompt_workspace_root)
+        root = prompt_workspace_root
         unless full_path == root || full_path.start_with?("#{root}/")
           @editor_state.status = "Cannot save outside workspace"
           return false

data/lib/kward/prompt_interface/editor/modes/vibe.rb

@@ -280,8 +280,8 @@ module Kward
 
       def vibe_path_completion_candidates(prefix)
         directory_prefix, basename_prefix = vibe_split_path_completion_prefix(prefix)
-        search_directory = File.expand_path(directory_prefix.empty? ? "." : directory_prefix, Dir.pwd)
-        root = File.expand_path(Dir.pwd)
+        search_directory = File.expand_path(directory_prefix.empty? ? "." : directory_prefix, prompt_workspace_root)
+        root = prompt_workspace_root
         return [] unless search_directory == root || search_directory.start_with?("#{root}/")
         return [] unless File.directory?(search_directory)
 

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

@@ -34,7 +34,7 @@ module Kward
         rows = [editor_top_border(width)]
         rows.concat(visible_lines.each_with_index.map do |line, index|
           gutter = if index < actual_visible_count
-                     editor_line_number_gutter(@editor_state.viewport_row + index)
+                     editor_line_number_gutter(@editor_state.viewport_row + index, line_index)
                    else
                      editor_blank_line_number_gutter
                    end
@@ -59,7 +59,7 @@ module Kward
         rows = [editor_top_border(width)]
         rows.concat(visible_rows.map do |visual_row|
           if visual_row
-            gutter = visual_row[:continuation] ? editor_blank_line_number_gutter : editor_line_number_gutter(visual_row[:line_index])
+            gutter = visual_row[:continuation] ? editor_blank_line_number_gutter : editor_line_number_gutter(visual_row[:line_index], line_index)
             rendered_line = editor_render_line(visual_row[:line], visual_row[:line_index], text_width, column_offset: visual_row[:column_offset])
             box_content_row(gutter + rendered_line, content_width)
           else
@@ -230,16 +230,16 @@ module Kward
         (column.to_i / text_width) * text_width
       end
 
-      def editor_line_number_gutter(line_index)
-        number = editor_display_line_number(line_index).to_s.rjust(editor_line_number_gutter_width - 3)
-        colored("#{number} │ ", :dark_forest_green)
+      def editor_line_number_gutter(line_index, cursor_line)
+        number = editor_display_line_number(line_index, cursor_line).to_s.rjust(editor_line_number_gutter_width - 3)
+        number_color = line_index == cursor_line ? :white : :dark_forest_green
+        colored(number, number_color) + colored(" │ ", :dark_forest_green)
       end
 
-      def editor_display_line_number(line_index)
+      def editor_display_line_number(line_index, cursor_line)
         return line_index + 1 unless current_editor_line_numbers == "relative"
         return line_index + 1 if @editor_state.readonly?
 
-        cursor_line, = @editor_state.cursor_line_and_column
         line_index == cursor_line ? line_index + 1 : (line_index - cursor_line).abs
       end
 
@@ -257,7 +257,7 @@ module Kward
 
       def editor_display_path
         path = @editor_state.path || @editor_state.display_path
-        Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+        Pathname.new(path).relative_path_from(Pathname.new(prompt_workspace_root)).to_s
       rescue StandardError
         @editor_state.display_path || @editor_state.path
       end

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

@@ -793,21 +793,15 @@ module Kward
       end
 
       def cursor_line_and_column_for(offset)
-        before_cursor = @buffer[0...offset].to_s
-        [before_cursor.count("\n"), (before_cursor.split("\n", -1).last || "").length]
+        @text_buffer.line_and_column_for(offset)
       end
 
       def line_start_offset(line_index)
-        values = lines
-        line_index = [[line_index.to_i, 0].max, values.length - 1].min
-        values.first(line_index).sum { |line| line.length + 1 }
+        @text_buffer.line_start_offset(line_index)
       end
 
       def line_range(line_index)
-        start_index = line_start_offset(line_index)
-        end_index = start_index + lines[line_index].to_s.length
-        end_index += 1 if end_index < @buffer.length
-        [start_index, end_index]
+        @text_buffer.line_range(line_index)
       end
 
       def word_range_at(offset)

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

@@ -11,20 +11,24 @@ module Kward
       ].freeze
       RUBY_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|:[a-zA-Z_]\w*[!?=]?|\b\d+(?:\.\d+)?\b|\b[A-Z]\w*\b|\b(?:#{Regexp.union(RUBY_KEYWORDS)})\b)/.freeze
       MARKDOWN_PATTERN = /(`[^`\n]+`|!?\[[^\]\n]+\]\([^\)\n]+\)|(?:\*\*|__)[^\n]+?(?:\*\*|__)|(?:\*|_)[^\n]+?(?:\*|_))/.freeze
-      HTML_PATTERN = /(<!--.*?-->|<\/?[A-Za-z][^>]*>|\b[A-Za-z_:-]+(?=\=)|"[^"]*"|'[^']*')/.freeze
+      HTML_TAG_START_PATTERN = /<\/?[A-Za-z][\w:-]*/.freeze
       CSS_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|#[0-9a-fA-F]{3,8}\b|\.[A-Za-z_-][\w-]*|#[A-Za-z_-][\w-]*|\b\d+(?:\.\d+)?(?:px|em|rem|%|vh|vw|s|ms)?\b|[A-Za-z_-][\w-]*(?=\s*:)|@[A-Za-z_-][\w-]*)/.freeze
       JSON_PATTERN = /("(?:\\.|[^"\\])*"(?=\s*:)|"(?:\\.|[^"\\])*"|\b(?:true|false|null)\b|-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b)/.freeze
       YAML_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\b(?:true|false|null|yes|no|on|off)\b|\b\d+(?:\.\d+)?\b|[A-Za-z0-9_-]+(?=\s*:))/.freeze
       SQL_PATTERN = /("(?:\\.|[^"\\])*"|'(?:''|[^'])*'|--.*|\b\d+(?:\.\d+)?\b|\b(?:SELECT|FROM|WHERE|JOIN|LEFT|RIGHT|INNER|OUTER|ON|INSERT|INTO|UPDATE|DELETE|CREATE|ALTER|DROP|TABLE|VIEW|INDEX|VALUES|SET|AND|OR|NOT|NULL|IS|AS|ORDER|BY|GROUP|HAVING|LIMIT|OFFSET|DISTINCT|UNION|ALL|CASE|WHEN|THEN|ELSE|END|PRIMARY|KEY|FOREIGN|REFERENCES|DEFAULT|TRUE|FALSE)\b)/i.freeze
       GENERIC_STRING_NUMBER_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b\d+(?:\.\d+)?\b)/.freeze
+      ERB_OPEN_PATTERN = /<%[#=]?/.freeze
+      ERB_CLOSE_PATTERN = /-?%>/.freeze
 
       LANGUAGE_DEFINITIONS = {
         javascript: {
           extensions: %w[.js .jsx .mjs .cjs],
+          block_comment: true,
           keywords: %w[async await break case catch class const continue debugger default delete do else export extends false finally for from function if import in instanceof let new null of return static super switch this throw true try typeof undefined var void while with yield]
         },
         typescript: {
           extensions: %w[.ts .tsx],
+          block_comment: true,
           keywords: %w[abstract any as async await boolean break case catch class const constructor continue debugger declare default delete do else enum export extends false finally for from function if implements import in infer instanceof interface is keyof let module namespace never new null number object of private protected public readonly return static string super switch symbol this throw true try type typeof undefined unknown var void while with yield]
         },
         shell: {
@@ -60,34 +64,42 @@ module Kward
         },
         go: {
           extensions: %w[.go],
+          block_comment: true,
           keywords: %w[break case chan const continue default defer else fallthrough false for func go goto if import interface map nil package range return select struct switch true type var]
         },
         rust: {
           extensions: %w[.rs],
+          block_comment: true,
           keywords: %w[as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while]
         },
         java: {
           extensions: %w[.java],
+          block_comment: true,
           keywords: %w[abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while]
         },
         csharp: {
           extensions: %w[.cs],
+          block_comment: true,
           keywords: %w[abstract as base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern false finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new null object operator out override params private protected public readonly ref return sbyte sealed short sizeof stackalloc static string struct switch this throw true try typeof uint ulong unchecked unsafe ushort using virtual void volatile while var async await]
         },
         c: {
           extensions: %w[.c .h],
+          block_comment: true,
           keywords: %w[auto break case char const continue default do double else enum extern float for goto if inline int long register restrict return short signed sizeof static struct switch typedef union unsigned void volatile while]
         },
         cpp: {
           extensions: %w[.cc .cpp .cxx .hpp .hh .hxx],
+          block_comment: true,
           keywords: %w[alignas alignof and asm auto bool break case catch char char16_t char32_t class const constexpr const_cast continue decltype default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new noexcept nullptr operator or private protected public register reinterpret_cast return short signed sizeof static static_assert static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar_t while]
         },
         swift: {
           extensions: %w[.swift],
+          block_comment: true,
           keywords: %w[as associatedtype break case catch class continue default defer deinit do else enum extension false fileprivate for func guard if import in init inout internal is let nil open operator private protocol public repeat rethrows return self Self static struct subscript super switch throw throws true try typealias var where while]
         },
         kotlin: {
           extensions: %w[.kt .kts],
+          block_comment: true,
           keywords: %w[as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while by catch constructor delegate dynamic field file finally get import init param property receiver set setparam where actual abstract annotation companion const crossinline data enum expect external final infix inline inner internal lateinit noinline open operator out override private protected public reified sealed suspend tailrec vararg]
         },
         lua: {
@@ -103,6 +115,7 @@ module Kward
       JSON_EXTENSIONS = %w[.json].freeze
       YAML_EXTENSIONS = %w[.yml .yaml].freeze
       HTML_EXTENSIONS = %w[.html .htm].freeze
+      ERB_EXTENSIONS = %w[.erb].freeze
       CSS_EXTENSIONS = %w[.css].freeze
       SCSS_EXTENSIONS = %w[.scss].freeze
       SQL_EXTENSIONS = %w[.sql].freeze
@@ -123,6 +136,8 @@ module Kward
           editor_highlight_yaml(line)
         when :html
           editor_highlight_html(line)
+        when :erb
+          editor_highlight_erb(line, line_index)
         when :css, :scss
           editor_highlight_css(line)
         when :sql
@@ -153,6 +168,7 @@ module Kward
         return :json if JSON_EXTENSIONS.include?(extension)
         return :yaml if YAML_EXTENSIONS.include?(extension)
         return :html if HTML_EXTENSIONS.include?(extension)
+        return :erb if ERB_EXTENSIONS.include?(extension)
         return :scss if SCSS_EXTENSIONS.include?(extension)
         return :css if CSS_EXTENSIONS.include?(extension)
         return :sql if SQL_EXTENSIONS.include?(extension)
@@ -174,6 +190,80 @@ module Kward
         editor_highlight_ruby_code(text[0...comment_index].to_s) + colored(text[comment_index..].to_s, :gray)
       end
 
+      def editor_highlight_erb(line, line_index = nil)
+        segments, = editor_erb_segments(line.to_s, editor_erb_state_before_line(line_index))
+        output = +""
+        comment = +""
+        html_in_tag = false
+
+        segments.each do |kind, text|
+          if kind == :comment
+            comment << text
+            next
+          end
+
+          unless comment.empty?
+            output << colored(comment, :gray)
+            comment.clear
+          end
+          case kind
+          when :template
+            highlighted, html_in_tag = editor_highlight_html_segment(text, in_tag: html_in_tag)
+            output << highlighted
+          when :ruby
+            output << editor_highlight_ruby(text)
+          when :delimiter
+            output << colored(text, :cyan)
+          end
+        end
+        output << colored(comment, :gray) unless comment.empty?
+        output
+      end
+
+      def editor_erb_state_before_line(line_index)
+        return :template unless line_index && @editor_state
+
+        state = :template
+        @editor_state.lines.first(line_index.to_i).each do |line|
+          _, state = editor_erb_segments(line.to_s, state)
+        end
+        state
+      end
+
+      def editor_erb_segments(text, state)
+        segments = []
+        cursor = 0
+
+        while cursor < text.length
+          if state == :template
+            opening = text.match(ERB_OPEN_PATTERN, cursor)
+            if opening
+              segments << [:template, text[cursor...opening.begin(0)].to_s] unless opening.begin(0) == cursor
+              opening_kind = opening[0] == "<%#" ? :comment : :delimiter
+              segments << [opening_kind, opening[0]]
+              state = opening_kind == :comment ? :comment : :ruby
+              cursor = opening.end(0)
+            else
+              segments << [:template, text[cursor..].to_s]
+              break
+            end
+          else
+            closing = text.match(ERB_CLOSE_PATTERN, cursor)
+            if closing
+              segments << [state, text[cursor...closing.begin(0)].to_s] unless closing.begin(0) == cursor
+              segments << [state == :comment ? :comment : :delimiter, closing[0]]
+              state = :template
+              cursor = closing.end(0)
+            else
+              segments << [state, text[cursor..].to_s]
+              break
+            end
+          end
+        end
+
+        [segments, state]
+      end
+
       def editor_highlight_ruby_code(line)
         line.to_s.gsub(RUBY_PATTERN) do |token|
           editor_highlight_ruby_token(token)
@@ -216,8 +306,7 @@ module Kward
         return line.to_s unless definition
 
         text = line.to_s
-        return colored(text, :gray) if editor_c_style_block_comment_line?(line_index)
-
+        return colored(text, :gray) if definition[:block_comment] && editor_c_style_block_comment_line?(line_index)
         marker = definition[:line_comment] || "//"
         comment_index = editor_comment_index(text, marker)
         return editor_highlight_generic_code(text, definition[:keywords]) unless comment_index
@@ -233,7 +322,8 @@ module Kward
       end
 
       def editor_generic_pattern(keywords)
-        /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b\d+(?:\.\d+)?\b|\b[A-Z]\w*\b|\b(?:#{Regexp.union(keywords)})\b)/
+        @editor_generic_patterns ||= {}
+        @editor_generic_patterns[keywords] ||= /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b\d+(?:\.\d+)?\b|\b[A-Z]\w*\b|\b(?:#{Regexp.union(keywords)})\b)/
       end
 
       def editor_highlight_generic_token(token, keywords)
@@ -253,16 +343,31 @@ module Kward
       def editor_c_style_block_comment_line?(line_index)
         return false unless line_index && @editor_state
 
-        in_comment = false
-        @editor_state.lines.first(line_index.to_i + 1).each_with_index do |line, index|
+        lines = @editor_state.lines
+        unless @editor_block_comment_lines.equal?(lines)
+          @editor_block_comment_lines = lines
+          @editor_block_comment_states = []
+          @editor_block_comment_in_comment = false
+        end
+
+        target = line_index.to_i
+        return false if target.negative?
+        return @editor_block_comment_states[target] if target < @editor_block_comment_states.length
+
+        (@editor_block_comment_states.length..target).each do |index|
+          line = lines[index].to_s
           starts_block = editor_comment_index(line, "/*")
-          ends_block = in_comment && line.include?("*/")
-          return true if index == line_index && (in_comment || starts_block)
+          ends_block = @editor_block_comment_in_comment && line.include?("*/")
+          @editor_block_comment_states << (@editor_block_comment_in_comment || !starts_block.nil?)
 
-          in_comment = true if starts_block && !line[starts_block..].to_s.include?("*/")
-          in_comment = false if ends_block
+          if starts_block && !line[starts_block..].to_s.include?("*/")
+            @editor_block_comment_in_comment = true
+          elsif ends_block
+            @editor_block_comment_in_comment = false
+          end
         end
-        false
+
+        @editor_block_comment_states[target]
       end
 
       def editor_comment_index(line, marker)
@@ -372,17 +477,112 @@ module Kward
       end
 
       def editor_highlight_html(line)
-        line.to_s.gsub(HTML_PATTERN) do |token|
-          if token.start_with?("<!--")
-            colored(token, :gray)
-          elsif token.start_with?("<")
-            colored(token, :blue)
-          elsif token.start_with?("\"", "'")
-            colored(token, :green)
+        highlighted, = editor_highlight_html_segment(line.to_s)
+        highlighted
+      end
+
+      def editor_highlight_html_segment(text, in_tag: false)
+        output = +""
+        cursor = 0
+
+        while cursor < text.length
+          if in_tag
+            close_index = text.index(">", cursor)
+            if close_index
+              output << editor_highlight_html_tag_fragment(text[cursor..close_index].to_s)
+              cursor = close_index + 1
+              in_tag = false
+            else
+              output << editor_highlight_html_tag_fragment(text[cursor..].to_s)
+              break
+            end
+            next
+          end
+
+          comment_index = text.index("<!--", cursor)
+          tag = text.match(HTML_TAG_START_PATTERN, cursor)
+          next_match = [comment_index, tag&.begin(0)].compact.min
+          unless next_match
+            output << text[cursor..].to_s
+            break
+          end
+
+          output << text[cursor...next_match].to_s if next_match > cursor
+          if comment_index == next_match
+            close_index = text.index("-->", comment_index + 4)
+            end_index = close_index ? close_index + 3 : text.length
+            output << colored(text[comment_index...end_index].to_s, :gray)
+            cursor = end_index
           else
-            colored(token, :cyan)
+            close_index = text.index(">", tag.end(0))
+            end_index = close_index ? close_index + 1 : text.length
+            output << editor_highlight_html_tag_fragment(text[tag.begin(0)...end_index].to_s)
+            cursor = end_index
+            in_tag = close_index.nil?
           end
         end
+
+        [output, in_tag]
+      end
+
+      def editor_highlight_html_tag_fragment(tag)
+        output = +""
+        cursor = 0
+        head = tag.match(/\A<\/?[A-Za-z][\w:-]*/)
+        if head
+          output << colored(head[0], :blue)
+          cursor = head.end(0)
+        end
+
+        while cursor < tag.length
+          rest = tag[cursor..].to_s
+          if rest.start_with?(">", "/>")
+            output << colored(rest.start_with?("/>") ? "/>" : ">", :blue)
+            cursor += rest.start_with?("/>") ? 2 : 1
+          elsif rest.match?(/\A\s/)
+            whitespace = rest[/\A\s+/]
+            output << whitespace
+            cursor += whitespace.length
+          elsif rest.start_with?("\"", "'")
+            quote = rest[0]
+            close_index = rest.index(quote, 1)
+            if close_index
+              end_index = close_index + 1
+              output << colored(rest[0...end_index], :green)
+              cursor += end_index
+            elsif rest.end_with?(">") && rest.length > 1
+              output << colored(rest[0...-1], :green)
+              output << colored(">", :blue)
+              cursor += rest.length
+            else
+              output << colored(rest, :green)
+              cursor += rest.length
+            end
+          elsif (attribute = rest.match(/\A([A-Za-z_:][\w:.-]*)(\s*=\s*)/))
+            output << colored(attribute[1], :cyan)
+            output << attribute[2]
+            cursor += attribute[0].length
+            value = tag[cursor..].to_s
+            if value.start_with?("\"", "'")
+              quote = value[0]
+              close_index = value.index(quote, 1)
+              end_index = close_index ? close_index + 1 : value.length
+              output << colored(value[0...end_index], :green)
+              cursor += end_index
+            elsif (unquoted = value.match(/\A[^\s>]+/))
+              output << colored(unquoted[0], :green)
+              cursor += unquoted[0].length
+            end
+          elsif (attribute = rest.match(/\A[A-Za-z_:][\w:.-]*/))
+            output << colored(attribute[0], :cyan)
+            cursor += attribute[0].length
+          else
+            output << rest[0]
+            cursor += 1
+          end
+        end
+
+        output
       end
 
       def editor_highlight_css(line)

data/lib/kward/prompt_interface/file_overlay.rb

@@ -133,11 +133,11 @@ module Kward
       end
 
       def git_project_file_paths
-        ProjectFiles.git_paths(Dir.pwd)
+        ProjectFiles.git_paths(prompt_workspace_root)
       end
 
       def scanned_project_file_paths
-        ProjectFiles.scanned_paths(Dir.pwd)
+        ProjectFiles.scanned_paths(prompt_workspace_root)
       end
 
       def selected_file_mention_path

data/lib/kward/prompt_interface/git_prompt.rb

@@ -84,6 +84,8 @@ module Kward
         binding_result = handle_composer_key_binding(key) if git_composing?
         return binding_result unless binding_result == false || binding_result.nil?
 
+        return git_move_selection(1) if key == "j" && !git_composing?
+        return git_move_selection(-1) if key == "k" && !git_composing?
         return git_toggle_selected_file if key == "s" && !git_composing?
 
         insert_key(key) if git_composing?
@@ -111,8 +113,10 @@ module Kward
           delete_at_cursor if git_composing?
           nil
         else
-          if !git_composing? && code == "s".ord && (sequence[:modifiers].to_s.empty? || sequence[:modifiers].to_s == "1")
-            return git_toggle_selected_file
+          unless git_composing?
+            return git_move_selection(1) if code == "j".ord
+            return git_move_selection(-1) if code == "k".ord
+            return git_toggle_selected_file if code == "s".ord && (sequence[:modifiers].to_s.empty? || sequence[:modifiers].to_s == "1")
           end
           return false unless git_composing?
 
@@ -265,7 +269,7 @@ module Kward
       def git_overlay_rows(width, height: screen_height)
         return [] unless @git_state
 
-        help = git_composing? ? "Type commit message · Enter commit · Tab overlay · Esc cancel" : "↑/↓ select · Enter diff · s stage/unstage · Tab message · Esc cancel"
+        help = git_composing? ? "Type commit message · Enter commit · Tab overlay · Esc cancel" : "↑/↓/j/k select · Enter diff · s stage/unstage · Tab message · Esc cancel"
         lines = [overlay_text_line(help, :muted), overlay_blank_line]
         status_lines = @git_state[:status_lines]
         status_lines = ["No uncommitted changes."] if status_lines.empty?

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

@@ -45,7 +45,8 @@ module Kward
         @on_tick = block
       end
 
-      # Places a character at the given canvas position with optional color.
+      # Stages a character at the given canvas position with optional color.
+      # Call {#render} after completing the frame to publish it.
       #
       # @param row [Integer] zero-based row
       # @param col [Integer] zero-based column
@@ -59,15 +60,14 @@ module Kward
         return if col.negative? || col >= @width
 
         @cells[row][col] = { char: char.to_s[0] || " ", colors: colors.flatten }
-        @dirty = true
       end
 
-      # Clears all canvas cells to blank.
+      # Stages a reset of all canvas cells to blank. Call {#render} after
+      # completing the frame to publish it.
       #
       # @return [void]
       def clear_frame
         @cells = Array.new(@height) { Array.new(@width) { blank_cell } }
-        @dirty = true
       end
 
       # Marks the canvas as ready for Kward to render. Called after the plugin