llm.rb 13.0.0 → 14.0.0

data/lib/llm/repl/input.rb

@@ -6,6 +6,9 @@ class LLM::Repl
   # the editable input line shown at the bottom of the REPL.
   # @api private
   class Input
+    require_relative "input/row"
+    require_relative "input/char"
+
     CTRL = {
       A: Curses::KEY_CTRL_A,
       E: Curses::KEY_CTRL_E,
@@ -44,10 +47,6 @@ class LLM::Repl
     # distinguishes a paste from manual typing.
     PASTE_THRESHOLD = 0.05
 
-    ##
-    # @return [String]
-    attr_reader :buffer
-
     ##
     # @param [Boolean] value
     # @return [void]
@@ -60,8 +59,8 @@ class LLM::Repl
       @name = repl.name
       @agent = repl.agent
       @provider = @agent.llm.name
-      @buffer = +""
-      @cursor = 0
+      @rows = [Row.new]
+      @cursor = [0, 0]
       @scroll = 0
       @height = options.fetch(:height, 3)
       @last_char_at = nil
@@ -70,6 +69,13 @@ class LLM::Repl
       @paste = false
     end
 
+    ##
+    # @return [String]
+    #  The input buffer as an ordinary string.
+    def buffer
+      text
+    end
+
     ##
     # @param [LLM::Repl::Window] window
     # @param [Object] char
@@ -91,12 +97,10 @@ class LLM::Repl
       elsif ESC == char
         @agent.cancel!
       elsif CTRL[:P] == char
-        @buffer = @walker.prev.dup
-        @cursor = @buffer.size
+        set(text: @walker.prev.dup)
         :ctrl_p
       elsif CTRL[:N] == char
-        @buffer = @walker.next.dup
-        @cursor = @buffer.size
+        set(text: @walker.next.dup)
         :ctrl_n
       elsif CTRL[:D] == char
         delete
@@ -130,7 +134,7 @@ class LLM::Repl
           insert("\n")
           :char
         else
-          @memory.push(@buffer.dup)
+          @memory.push(text)
           @walker.cursor = @memory.size
           :submit
         end
@@ -141,7 +145,16 @@ class LLM::Repl
         window.scroll_down
         :down
       elsif String === char
-        insert(char)
+        ##
+        # A paste arrives as a burst of fast characters. Flag it so the
+        # next loop iteration drains the rest through read_paste in a
+        # single shot, instead of inserting one character at a time and
+        # redrawing after each. A string that is already the product of
+        # read_paste (multi-character) is inserted as-is, one char at a
+        # time, so every newline creates a row and every Char stays a
+        # single character.
+        @paste = true if char.length == 1 && is_paste.()
+        char.each_char { |c| insert(c) }
         :char
       else
         nil
@@ -157,13 +170,10 @@ class LLM::Repl
     ##
     # @return [String]
     def to_s
-      "#{prompt}#{@buffer}"
-    end
-
-    ##
-    # @return [Integer]
-    def cursor
-      prompt.size + @cursor
+      @rows
+        .each_with_index
+        .map { |row, i| (i.zero? ? prompt : "") + row.to_s }
+        .join("\n")
     end
 
     ##
@@ -173,14 +183,15 @@ class LLM::Repl
     end
 
     ##
-    # Returns the visible lines of the input buffer,
-    # split by newlines. The viewport follows the cursor
-    # so the cursor line is always visible.
+    # Returns the visible lines of the input buffer. The viewport
+    # follows the cursor so the cursor line is always visible.
     # @return [Array<String>]
     def lines
       scroll!
-      chunks = to_s.split("\n", -1)
-      chunks[@scroll, height] || []
+      visible = @rows[@scroll, height] || []
+      visible.each_with_index.map do |row, i|
+        (i.zero? && @scroll.zero? ? prompt : "") + row.to_s
+      end
     end
 
     ##
@@ -189,46 +200,55 @@ class LLM::Repl
     # @return [Array(Integer, Integer)]
     def cursor_pos
       scroll!
-      before = to_s[0...cursor]
-      line  = before.count("\n")
-      col   = cursor - (before.rindex("\n") || -1) - 1
-      [line - @scroll, col]
+      row, col = @cursor
+      col += prompt.size if row.zero?
+      [row - @scroll, col]
     end
 
     ##
     # @return [void]
     def move_start
-      @cursor = 0
+      @cursor = [0, 0]
     end
 
     ##
     # @return [void]
     def move_end
-      @cursor = [0, @buffer.size].max
+      @cursor = [@rows.size - 1, @rows.last.chars.size]
     end
 
     ##
     # @return [void]
     def move_left
-      @cursor = [@cursor - 1, 0].max
+      row, col = @cursor
+      @cursor =
+        if col > 0 then [row, col - 1]
+        elsif row > 0 then [row - 1, @rows[row - 1].chars.size]
+        else [0, 0]
+        end
     end
 
     ##
     # @return [void]
     def move_right
-      @cursor = [@cursor + 1, @buffer.size].min
+      row, col = @cursor
+      @cursor =
+        if col < @rows[row].chars.size then [row, col + 1]
+        elsif row < @rows.size - 1 then [row + 1, 0]
+        else [row, col]
+        end
     end
 
     ##
     # @return [void]
     def move_forward
-      @cursor = [0, @cursor + 1].max
+      move_right
     end
 
     ##
     # @return [void]
     def autocomplete
-      return unless @buffer[0] == "/"
+      return unless text[0] == "/"
       ##
       # This method implements a simple autocomplete
       # that supports cycling through all known
@@ -237,45 +257,72 @@ class LLM::Repl
       # full match. However, it's not based on similarity,
       # it's just the next element in the array.
       keys = LLM::Command.registry.keys
-      candidates = LLM::Command.complete(@buffer)
-      if REPEATS[TAB] >= 1
-        candidate = keys[keys.index(candidates[0]) + 1] || keys[0]
-      else
-        candidate = candidates[0]
-      end
-      @buffer = "/#{candidate}"
-      @cursor = @buffer.size
+      candidates = LLM::Command.complete(text)
+      candidate =
+        if REPEATS[TAB] >= 1
+          keys[keys.index(candidates[0]) + 1] || keys[0]
+        else
+          candidates[0]
+        end
+      set(text: "/#{candidate}")
     end
 
     ##
     # @return [void]
     def kill
-      @copy = @buffer.slice(@cursor, @buffer.size)
-      @buffer[@cursor, @buffer.size] = ""
-      @cursor = @buffer.size
+      row, col = @cursor
+      tail = @rows[row].chars[col..].map(&:to_s).join
+      tail += @rows[(row + 1)..].map(&:to_s).join("\n")
+      @copy = tail
+      @rows[row].chars.slice!(col..)
+      @rows = @rows[0..row]
+      @cursor = [row, col]
     end
 
     ##
+    # Deletes the character at the cursor, or consumes
+    # the break and pulls up the next row at the end of
+    # a row.
     # @return [void]
     def delete
-      @buffer[@cursor] = ""
-      @cursor = [0, @cursor].max
+      row, col = @cursor
+      if col < @rows[row].chars.size
+        @rows[row].chars.delete_at(col)
+      elsif row < @rows.size - 1
+        nxt = @rows[row + 1]
+        ##
+        # A wrapped row was split at a space; restore it so
+        # the merged words don't run together.
+        @rows[row].chars << Char.new(" ") if nxt.break_type == :space
+        @rows[row].chars.concat(nxt.chars)
+        @rows.delete_at(row + 1)
+      end
     end
 
     ##
     # @return [void]
     def restore
       return unless @copy
-      @buffer.insert(@cursor, @copy)
-      @cursor += @copy.size
+      row, col = @cursor
+      @copy.each_char do |char|
+        if char == "\n"
+          @rows.insert(row + 1, Row.new(:newline))
+          row += 1
+          col = 0
+        else
+          @rows[row].chars.insert(col, Char.new(char))
+          col += 1
+        end
+      end
+      @cursor = [row, col]
     end
 
     ##
     # @return [String]
     def take
-      @buffer.dup.tap do
-        @buffer.clear
-        @cursor = 0
+      text.tap do
+        @rows = [Row.new]
+        @cursor = [0, 0]
         @scroll = 0
       end
     end
@@ -292,12 +339,12 @@ class LLM::Repl
     # Adjusts @scroll so the cursor line is visible within
     # the viewport.
     def scroll!(total_lines = nil)
-      total_lines ||= to_s.split("\n", -1).size
-      cursor_line = to_s[0...cursor].count("\n")
-      if cursor_line < @scroll
-        @scroll = cursor_line
-      elsif cursor_line >= (@scroll + height)
-        @scroll = (cursor_line - height) + 1
+      total_lines ||= @rows.size
+      cursor_row = @cursor[0]
+      if cursor_row < @scroll
+        @scroll = cursor_row
+      elsif cursor_row >= (@scroll + height)
+        @scroll = (cursor_row - height) + 1
       end
       @scroll = [[@scroll, (total_lines - height)].min, 0].max
     end
@@ -306,20 +353,158 @@ class LLM::Repl
       "#{@provider}(#{@name})> "
     end
 
+    ##
+    # Returns the line the cursor is on, including the prompt.
+    # @return [String]
+    def current_line
+      row = @cursor[0]
+      (row.zero? ? prompt : "") + @rows[row].to_s
+    end
+
+    ##
+    # Inserts a character at the cursor, wrapping the current row at
+    # the terminal width by starting a new row. A word that would be
+    # cut in half is moved whole onto the new row.
+    # @param [String] char
+    # @return [void]
     def insert(char)
-      if lines[-1].size >= Curses.cols
-        @buffer.insert(@cursor, "\n")
-        @cursor += 1
+      row, col = @cursor
+      if char == "\n"
+        @rows.insert(row + 1, Row.new(:newline))
+        @cursor = [row + 1, 0]
+      elsif current_line.size >= Curses.cols
+        if char == " "
+          @rows.insert(row + 1, Row.new(:space))
+          @cursor = [row + 1, 0]
+        elsif (index = current_line.rindex(" "))
+          offset = row.zero? ? prompt.size : 0
+          split = index - offset
+          tail = @rows[row].chars.slice!((split + 1)..) || []
+          @rows[row].chars.delete_at(split)
+          @rows.insert(row + 1, Row.new(:space))
+          @rows[row + 1].chars.concat(tail)
+          @rows[row + 1].chars << Char.new(char)
+          @cursor = [row + 1, @rows[row + 1].chars.size]
+        else
+          @rows.insert(row + 1, Row.new(:space))
+          @rows[row + 1].chars << Char.new(char)
+          @cursor = [row + 1, 1]
+        end
+      else
+        @rows[row].chars.insert(col, Char.new(char))
+        @cursor = [row, col + char.length]
       end
-      @buffer.insert(@cursor, char)
-      @cursor += char.length
       scroll!
     end
 
+    ##
+    # @return [void]
     def backspace
-      return if @cursor <= 0
-      @buffer.slice!(@cursor - 1)
-      @cursor -= 1
+      row, col = @cursor
+      if col > 0
+        @rows[row].chars.delete_at(col - 1)
+        @cursor = [row, col - 1]
+      elsif row > 0
+        prev = @rows[row - 1]
+        prev.chars.concat(@rows[row].chars)
+        @rows.delete_at(row)
+        @cursor = [row - 1, prev.chars.size]
+      end
+    end
+
+    ##
+    # Flattens the rows into a single string. Each row joins the one
+    # before it using its own `break_type`: a row started by an
+    # auto-wrap joins with a space, a row started by a real newline
+    # joins with a newline.
+    # @return [String]
+    def text
+      out = +""
+      @rows.each_with_index do |row, i|
+        out << row.to_s
+        nxt = @rows[i + 1]
+        if nxt
+          out << (nxt.break_type == :newline ? "\n" : " ")
+        end
+      end
+      out
+    end
+
+    ##
+    # Feeds one character into the row model: newlines
+    # start a row, overflowing rows wrap at a word.
+    # @param [String] char
+    # @return [void]
+    def feed(char)
+      if char == "\n"
+        ##
+        # A real newline is a row boundary in the model,
+        # not a character, so it becomes a new row.
+        @rows << Row.new(:newline)
+        return
+      end
+      row = @rows.last
+      ##
+      # Only the first row shares its columns with the prompt,
+      # so it has fewer columns left for text.
+      width = Curses.cols - (row.equal?(@rows.first) ? prompt.size : 0)
+      if row.chars.any? and row.to_s.length + 1 > width
+        wrap(row)
+      end
+      @rows.last.chars << Char.new(char)
+    end
+
+    ##
+    # Moves the word tail of a full row onto a new
+    # continuation row, keeping the overflow word whole.
+    # @param [LLM::Repl::Input::Row] row
+    # @return [void]
+    def wrap(row)
+      index = row.to_s.rindex(" ")
+      if index
+        ##
+        # Move everything after the last space down and
+        # drop the space; break_type restores it on flatten.
+        tail = row.chars.slice!((index + 1)..) || []
+        row.chars.pop
+        @rows << Row.new(:space).tap { |r| r.chars.concat(tail) }
+      else
+        ##
+        # A single unbroken word longer than the width hard-breaks.
+        @rows << Row.new(:space)
+      end
+    end
+
+    ##
+    # Replaces the input with the given text, reflowing it into rows
+    # at the terminal width. The cursor ends at the last row.
+    # @param [String] text
+    # @return [void]
+    def set(text:)
+      return if noop_set?(text)
+      @rows = [Row.new]
+      text.each_char { |char| feed(char) }
+      ##
+      # A trailing newline leaves an empty last row; drop it
+      # so the cursor rests at the end of the content row.
+      @rows.pop while @rows.size > 1 and @rows.last.empty?
+      @cursor = [@rows.size - 1, @rows.last.chars.size]
+    end
+
+    ##
+    # Returns true when the {#set} method should return early.
+    # @param [String, nil] str
+    #  The new string to set.
+    # @return [Boolean]
+    def noop_set?(str)
+      if str.nil?
+        true
+      elsif @rows.size == 1
+        chars = @rows[0].to_s
+        str.empty? and chars.empty?
+      else
+        false
+      end
     end
   end
 end

data/lib/llm/repl/markdown/table.rb

@@ -4,6 +4,13 @@ class LLM::Repl::Markdown
   ##
   # Renders Kramdown `:table` nodes as aligned columns.
   module Table
+    ##
+    # @api private
+    Node  = LLM::Repl::Node
+    Color = LLM::Repl::Color
+    private_constant :Node
+    private_constant :Color
+
     ##
     # Renders a table node by collecting all cells first to
     # compute column widths, then emitting each row with
@@ -15,7 +22,6 @@ class LLM::Repl::Markdown
       rows.each do |row|
         emit("| ", attrs)
         row.each_with_index do |chunks, i|
-          text = chunks.map { _1[:text] }.join
           width = widths[i]
           chunks.each { |c| emit(c[:text].ljust(width), c[:attrs]) }
           emit(" | ", attrs) unless i == row.size - 1
@@ -51,15 +57,17 @@ class LLM::Repl::Markdown
     def walk_collect(node, attrs, chunks)
       case node.type
       when :text
-        chunks << {text: node.value.to_s, attrs:}
+        chunks << Node.new(node.value.to_s, attrs)
       when :strong
         node.children.each { walk_collect(_1, Curses::A_BOLD, chunks) }
       when :em
         node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
       when :codespan
-        chunks << {text: node.value, attrs: Curses::A_REVERSE}
+        chunks << Node.new(node.value, Color.green)
       when :a
         node.children.each { walk_collect(_1, Curses::A_UNDERLINE, chunks) }
+      when :typographic_sym, :smart_quote
+        chunks << Node.new(symbol(node), attrs)
       else
         node.children.each { walk_collect(_1, attrs, chunks) }
       end

data/lib/llm/repl/markdown.rb

@@ -11,6 +11,26 @@ class LLM::Repl
     require_relative "markdown/table"
     include Table
 
+    ##
+    # Kramdown goes a bit beyond a standard markdown
+    # parser by representing certain characters or
+    # character sequences as distinct node types that are
+    # represented by `:typographic_sym`, and `:smart_quote`.
+    #
+    # The node's value maps back to one of the keys in
+    # this Hash, and the values are unicode characters
+    # that provide a visual representation of the node.
+    #
+    # @api private
+    SYMBOLS = {
+      hellip: "…",
+      ndash:  "–", mdash:  "—",
+      laquo:  "«", raquo:  "»",
+      laquo_space: "« ", raquo_space: "» ",
+      lsquo:  "‘", rsquo:  "’",
+      ldquo:  "“", rdquo:  "”"
+    }
+
     ##
     # @param [String] text
     # @param [Integer] width
@@ -22,7 +42,7 @@ class LLM::Repl
     end
 
     ##
-    # @return [Array<Hash>]
+    # @return [Array<Node>]
     def ast
       @ast.tap do
         ##
@@ -65,17 +85,19 @@ class LLM::Repl
         emit("\n\n", attrs)
       when :header
         emit("\n", attrs)
-        node.children.each { walk(_1, Curses::A_BOLD) }
+        node.children.each { walk(_1, Curses::A_BOLD | Color.white) }
         emit("\n", attrs)
       when :strong
-        node.children.each { walk(_1, Curses::A_BOLD) }
+        node.children.each { walk(_1, Curses::A_BOLD | Color.white) }
       when :em
         node.children.each { walk(_1, Curses::A_UNDERLINE) }
       when :codespan
-        emit(node.value, Curses::A_REVERSE)
+        emit(node.value, Color.green)
       when :codeblock
-        emit(node.value, Curses::A_REVERSE)
+        emit(node.value, Color.green)
         emit("\n\n", attrs)
+      when :typographic_sym, :smart_quote
+        emit(symbol(node), attrs)
       when :br
         emit("\n", attrs)
       when :ul, :ol
@@ -100,16 +122,20 @@ class LLM::Repl
         emit("─" * @width, attrs)
         emit("\n\n", attrs)
       when :a
-        node.children.each { walk(_1, Curses::A_UNDERLINE) }
+        node.children.each { walk(_1, Curses::A_UNDERLINE | Color.green) }
       when :img
-        emit("[image: #{node.attr['alt']}]", attrs)
+        emit("[image: #{node.attr["alt"]}]", attrs)
       else
         node.children.each { walk(_1, attrs) }
       end
     end
 
     def emit(text, attrs)
-      @ast.push({text: text.to_s, attrs:}.compact)
+      @ast.push(Node.new(text.to_s, attrs))
+    end
+
+    def symbol(node)
+      SYMBOLS[node.value]
     end
   end
 end

data/lib/llm/repl/node.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Node LLM::Repl::Node} class wraps a piece
+  # of text and optional curses attributes.
+  # @api private
+  class Node
+    ##
+    # @return [String]
+    attr_reader :text
+
+    ##
+    # @return [Integer, nil]
+    attr_reader :attrs
+
+    ##
+    # @param [String] text
+    # @param [Integer, nil] attrs
+    # @return [LLM::Repl::Node]
+    def initialize(text, attrs = nil)
+      @text = text.to_s
+      @attrs = attrs
+    end
+
+    ##
+    # Hash-like lookup.
+    # @param [Symbol] key
+    # @return [String, Integer, nil]
+    def [](key)
+      case key
+      when :text then @text
+      when :attrs then @attrs
+      end
+    end
+  end
+end