llm.rb 15.0.3 → 15.2.0

data/lib/llm/{repl/commands/compact.rb → console/commands/keep.rb}

@@ -1,25 +1,27 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The 'compact' command frees space in the
+  # The 'keep' command frees space in the
   # context window and llm.rb is designed to
   # support multiple compaction strategies with
   # different trade offs. This command, though,
   # uses the 'truncate' strategy. See
   # {LLM::Compactor::Truncate LLM::Compactor::Truncate}
   # for more details.
-  class Command::Compact < Command
-    name "compact"
-    description "frees space in the context window"
-    parameter :n, String, "the number of messages to keep"
+  class Command::Keep < Command
+    name "keep"
+    description "free space in the context window"
+    parameter :n, String, "the number of messages to keep\n" \
+                          "it can also be given as a percentage."
+    required %i[n]
 
     ##
     # @return [void]
-    def call(n: 128)
-      write "compact in progress"
+    def call(n:)
+      write "keep in progress"
       compactor.call(keep: n)
-      write "compact complete"
+      write "keep complete"
     end
 
     private

data/lib/llm/{repl → console}/commands/model.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
   # Switches the active model for the REPL.
-  # @see LLM::Repl#model=
+  # @see LLM::Console#model=
   class Model < Command
     name "model"
     description "switch the active model"

data/lib/llm/{repl → console}/input/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl::Input
+class LLM::Console::Input
   ##
   # Tracks the state of the active completion so that repeated
   # TAB presses can cycle through the candidate list.
@@ -9,7 +9,7 @@ class LLM::Repl::Input
     ##
     # @param [Array<String>] candidates
     # @param [Integer] index
-    # @return [LLM::Repl::Input::Cache]
+    # @return [LLM::Console::Input::Cache]
     def initialize(candidates, index)
       @candidates = candidates
       @index = index

data/lib/llm/{repl → console}/input/char.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-class LLM::Repl::Input
+class LLM::Console::Input
   ##
   # A single editable character of the input.
   class Char
     ##
     # @param [String] char
-    # @return [LLM::Repl::Input::Char]
+    # @return [LLM::Console::Input::Char]
     def initialize(char)
       @char = char
     end

data/lib/llm/{repl → console}/input/row.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl::Input
+class LLM::Console::Input
   ##
   # One line of the input. `chars` holds the editable characters.
   # `break_type` records how this line got started: an auto-wrap

data/lib/llm/{repl → console}/input.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Input LLM::Repl::Input} class manages
+  # The {LLM::Console::Input LLM::Console::Input} class manages
   # the editable input line shown at the bottom of the REPL.
   # @api private
   class Input
@@ -55,8 +55,8 @@ class LLM::Repl
     attr_writer :paste
 
     ##
-    # @param [LLM::Repl] repl
-    # @return [LLM::Repl::Input]
+    # @param [LLM::Console] console
+    # @return [LLM::Console::Input]
     def initialize(repl, options = {})
       @repl = repl
       @name = repl.name
@@ -80,7 +80,7 @@ class LLM::Repl
     end
 
     ##
-    # @param [LLM::Repl::Window] window
+    # @param [LLM::Console::Window] window
     # @param [Object] char
     # @return [Symbol, nil]
     def on_char(window, char, now)
@@ -99,6 +99,13 @@ class LLM::Repl
         :tab
       elsif ESC == char
         @agent.cancel!
+        ##
+        # '@agent.cancel!' might do this for us already
+        # but we can't rely on it alone. There are moments
+        # in time where '@agent.cancel!' is essentially a
+        # noop.
+        thread = @repl.thread
+        thread&.raise(LLM::Interrupt) if thread&.alive?
       elsif CTRL[:P] == char
         set(text: @walker.prev.dup)
         :ctrl_p
@@ -207,7 +214,8 @@ class LLM::Repl
     def cursor_pos
       scroll!
       row, col = @cursor
-      col += prompt.size if row.zero?
+      col = Node.width(@rows[row].chars[0...col].map(&:to_s).join)
+      col += Node.width(prompt) if row.zero?
       [row - @scroll, col]
     end
 
@@ -435,7 +443,7 @@ class LLM::Repl
       if char == "\n"
         @rows.insert(row + 1, Row.new(:newline))
         @cursor = [row + 1, 0]
-      elsif current_line.size >= Curses.cols
+      elsif Node.width(current_line) >= Curses.cols
         if char == " "
           @rows.insert(row + 1, Row.new(:space))
           @cursor = [row + 1, 0]
@@ -510,8 +518,8 @@ class LLM::Repl
       ##
       # 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
+      width = Curses.cols - (row.equal?(@rows.first) ? Node.width(prompt) : 0)
+      if row.chars.any? and Node.width(row.to_s) + 1 > width
         wrap(row)
       end
       @rows.last.chars << Char.new(char)
@@ -520,7 +528,7 @@ class LLM::Repl
     ##
     # Moves the word tail of a full row onto a new
     # continuation row, keeping the overflow word whole.
-    # @param [LLM::Repl::Input::Row] row
+    # @param [LLM::Console::Input::Row] row
     # @return [void]
     def wrap(row)
       index = row.to_s.rindex(" ")

data/lib/llm/console/markdown/parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class LLM::Console
+  ##
+  # Treats HTML and smart punctuation as plain text. Keep
+  # each parser registered (so kramdown's sub-parser lists,
+  # eg tables, still resolve) but point it at a no-op that
+  # emits the matched text literally instead of parsing it.
+  #
+  # Tables are enabled but only match when a header row is
+  # followed by a delimiter row (---). This breaks from
+  # default kramdown behavior which parses |foo| as a
+  # table.
+  class Markdown::Parser < ::Kramdown::Parser::Kramdown
+    ##
+    # Swap these parser slots for literal-text no-ops.
+    LITERAL = %i[span_html block_html smart_quotes typographic_syms]
+
+    ##
+    # A table starts with a header row that holds a pipe and
+    # a delimiter row (`---`). A lone `|foo|` in prose is not
+    # a table, so this matches only when a delimiter follows.
+    TABLE_START = /^[ \t]*(?=\S)#{TABLE_LINE}(?=#{TABLE_SEP_LINE})/m
+
+    def configure_parser
+      super
+      LITERAL.each { |name| swap(name, :"parse_#{name}") }
+      swap_table!
+    end
+
+    private
+
+    ##
+    # Replace a parser method with a no-op that emits its
+    # matched input literally, keeping the slot registered.
+    # @param [Symbol] name
+    # @param [Symbol] method
+    def swap(name, method)
+      data = @parsers[name]
+      @parsers[name] = Data.new(name, data.start_re, data.span_start, method)
+    end
+
+    ##
+    # Use a stricter start regexp for the table parser so bare
+    # pipe lines are not misread as tables, while kramdown's
+    # own parse_table still renders real tables.
+    def swap_table!
+      data = @parsers[:table]
+      @parsers[:table] = Data.new(:table, TABLE_START, data.span_start, data.method)
+    end
+
+    ##
+    # Emit the matched HTML tag literally. Falls back to the
+    # rest of the `<...` run when there is no closing `>`.
+    def parse_span_html
+      text = @src.scan_until(/>/)
+      add_text(text || @src.scan(/<[^>]*/))
+    end
+
+    ##
+    # Emit the matched HTML line literally.
+    def parse_block_html
+      add_text(@src.scan(/[^\n]*/))
+    end
+
+    ##
+    # Emit the smart quote literally instead of substituting.
+    def parse_smart_quotes
+      add_text(@src.scan(SMART_QUOTES_RE))
+    end
+
+    ##
+    # Emit the typographic symbol literally instead of mapping.
+    def parse_typographic_syms
+      add_text(@src.scan(TYPOGRAPHIC_SYMS_RE))
+    end
+  end
+end

data/lib/llm/{repl → console}/markdown/table.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-class LLM::Repl::Markdown
+class LLM::Console::Markdown
   ##
   # Renders Kramdown `:table` nodes as aligned columns.
   module Table
     ##
     # @api private
-    Node  = LLM::Repl::Node
-    Color = LLM::Repl::Color
+    Node  = LLM::Console::Node
+    Color = LLM::Console::Color
     private_constant :Node
     private_constant :Color
 
@@ -23,7 +23,10 @@ class LLM::Repl::Markdown
         emit("| ", attrs)
         row.each_with_index do |chunks, i|
           width = widths[i]
-          chunks.each { |c| emit(c[:text].ljust(width), c[:attrs]) }
+          chunks.each do |c|
+            text = c[:text].to_s
+            emit(text + (" " * (width - Node.width(text))), c[:attrs])
+          end
           emit(" | ", attrs) unless i == row.size - 1
         end
         emit(" |", attrs)
@@ -77,7 +80,7 @@ class LLM::Repl::Markdown
       return [] if rows.empty?
       cols = rows.first.size
       (0...cols).map do |i|
-        rows.map { |r| r[i].map { _1[:text] }.join.length }.max
+        rows.map { |r| Node.width(r[i].map { _1[:text] }.join) }.max
       end
     end
   end

data/lib/llm/{repl → console}/markdown.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
   # This class is designed to represent a markdown
   # string (typically from a model's response) as a
@@ -9,34 +9,21 @@ class LLM::Repl
   # that text (eg bold, underscore, ...)
   class Markdown
     require_relative "markdown/table"
+    require_relative "markdown/parser"
     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
-    # @return [LLM::Repl::Markdown]
+    # @return [LLM::Console::Markdown]
     def initialize(text, width)
-      @doc = Kramdown::Document.new(fenced_code_blocks(text))
+      ##
+      # 'Parser' treats HTML, smart quotes,
+      # and typographic symbols as literal
+      # text, so the original input comes
+      # through unchanged.
+      options = {input: Parser}
+      @doc = Kramdown::Document.new(fenced_code_blocks(text), options)
       @width = width
       @ast = []
     end
@@ -46,7 +33,7 @@ class LLM::Repl
     def ast
       @ast.tap do
         ##
-        # Recurisvely travels the markdown document and
+        # Recursively travels the markdown document and
         # populates the `@ast` variable along the way.
         # The AST is composed of structured data that
         # carries both text and styling information that
@@ -97,8 +84,8 @@ class LLM::Repl
         emit("#{lang(node)}\n", Curses::A_BOLD | Color.white) unless lang(node).empty?
         emit(node.value, Color.green)
         emit("\n\n", attrs)
-      when :typographic_sym, :smart_quote
-        emit(symbol(node), attrs)
+      when :entity
+        emit(node.value.char, attrs)
       when :br
         emit("\n", attrs)
       when :ul, :ol
@@ -135,10 +122,6 @@ class LLM::Repl
       @ast.push(Node.new(text.to_s, attrs))
     end
 
-    def symbol(node)
-      SYMBOLS[node.value]
-    end
-
     ##
     # Kramdown's native fenced-code syntax uses
     # `~~~`, not the GitHub-style ``` fences that

data/lib/llm/console/node.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+class LLM::Console
+  ##
+  # The {LLM::Console::Node LLM::Console::Node} class wraps a piece
+  # of text and optional curses attributes.
+  # @api private
+  class Node
+    ##
+    # Returns the display width of the given text, counting wide
+    # characters such as emoji as two columns.
+    # @param [#to_s] text
+    # @return [Integer]
+    def self.width(text)
+      Unicode::DisplayWidth.of(text.to_s)
+    end
+
+    ##
+    # Slices the given text so the returned piece has a display width
+    # of at most `width` columns.
+    # @param [#to_s] text
+    # @param [Integer] width
+    # @return [String]
+    def self.slice(text, width)
+      out = +""
+      text.to_s.each_char do |char|
+        break if self.width(out + char) > width
+        out << char
+      end
+      out
+    end
+
+    ##
+    # @return [String]
+    attr_reader :text
+
+    ##
+    # @return [Integer, nil]
+    attr_reader :attrs
+
+    ##
+    # @param [String] text
+    # @param [Integer, nil] attrs
+    # @return [LLM::Console::Node]
+    def initialize(text, attrs = nil)
+      @text = text.to_s
+      @attrs = attrs
+    end
+
+    ##
+    # Returns the display width of the text
+    # @return [Integer]
+    def size
+      self.class.width(@text)
+    end
+    alias_method :length, :size
+
+    ##
+    # 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

data/lib/llm/{repl → console}/status.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Status LLM::Repl::Status} class stores
+  # The {LLM::Console::Status LLM::Console::Status} class stores
   # the small status line shown at the top of the REPL.
   #
   # The status text can be a plain String, a single
-  # {LLM::Repl::Node LLM::Repl::Node} (text plus curses attributes),
+  # {LLM::Console::Node LLM::Console::Node} (text plus curses attributes),
   # or an Array of either. Attributes on nodes are applied when the
   # window draws the status line.
   # @api private
   class Status
     ##
-    # @param [LLM::Repl] repl
-    # @return [LLM::Repl::Status]
+    # @param [LLM::Console] console
+    # @return [LLM::Console::Status]
     def initialize(repl)
       @repl = repl
       @agent = repl.agent
@@ -24,7 +24,7 @@ class LLM::Repl
     ##
     # @return [String]
     def context_bar
-      LLM::Repl::Bar.new(
+      LLM::Console::Bar.new(
         ##
         # After compaction the used context is unknown until the next
         # response, so the bar renders an unknown state instead of a
@@ -41,22 +41,22 @@ class LLM::Repl
 
     ##
     # Returns the current model in use.
-    # @return [LLM::Repl::Node]
+    # @return [LLM::Console::Node]
     def model
       Node.new @repl.model.to_s, Curses::A_BOLD
     end
 
     ##
     # Returns the current working directory.
-    # @return [LLM::Repl::Node]
+    # @return [LLM::Console::Node]
     def cwd
       Node.new Dir.pwd.sub(Dir.home, "~"), Curses::A_BOLD
     end
 
     ##
     # Sets the status text.
-    # @param [String, LLM::Repl::Node, Array<String, LLM::Repl::Node>] value
-    # @return [Array<LLM::Repl::Node>]
+    # @param [String, LLM::Console::Node, Array<String, LLM::Console::Node>] value
+    # @return [Array<LLM::Console::Node>]
     def text=(value)
       @nodes =
         case value
@@ -78,7 +78,7 @@ class LLM::Repl
 
     ##
     # The nodes making up the status line.
-    # @return [Array<LLM::Repl::Node>]
+    # @return [Array<LLM::Console::Node>]
     def nodes
       if @agent.compacted?
         [Node.new("Context compacted")]

data/lib/llm/{repl → console}/stream.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Stream LLM::Repl::Stream} class manages
-  # the stream for the {LLM::Repl LLM::Repl} class. This class
+  # The {LLM::Console::Stream LLM::Console::Stream} class manages
+  # the stream for the {LLM::Console LLM::Console} class. This class
   # has defined hooks that receive text, tool calls, and
   # tool returns.
   # @api private
@@ -13,10 +13,11 @@ class LLM::Repl
     attr_reader :tools
 
     ##
-    # @param [LLM::Repl] repl
-    # @return [LLM::Repl::Stream]
+    # @param [LLM::Console] console
+    # @return [LLM::Console::Stream]
     def initialize(repl, queue)
       @repl = repl
+      @agent = @repl.agent
       @_queue = queue
       @buffer = +""
       @tools = {}
@@ -39,6 +40,14 @@ class LLM::Repl
       @_queue.push [:status, [" ", lambda, " • #{tool.name}(#{format_args(tool)})"]]
     end
 
+    ##
+    # @param [Exception] ex
+    # @param [Integer] attempt
+    # @return [void]
+    def on_retry(ex, attempt)
+      @_queue.push [:status, retry_error(ex, attempt)]
+    end
+
     ##
     # @param [LLM::Function] tool
     # @param [LLM::Function::Return] result
@@ -57,11 +66,29 @@ class LLM::Repl
     private
 
     ##
-    # @return [LLM::Repl::Node]
+    # @return [LLM::Agent]
+    def agent
+      @agent
+    end
+
+    ##
+    # @return [LLM::Console::Node]
     def lambda
       Node.new("λ", Curses::A_BOLD | Color.red)
     end
 
+    ##
+    # @return [LLM::Console::Node]
+    def retry_error(ex, attempt)
+      err = case ex.class.to_s
+      when "LLM::RateLimitError", "LLM::InsufficientQuotaError" then "Rate limited"
+      when "Net::ReadTimeout", "Net::WriteTimeout", "Net::OpenTimeout" then "Timed out"
+      else ex.class.to_s
+      end
+      [Node.new(" 🔁 "),
+       Node.new("#{err} • attempt #{attempt} of #{agent.retry_budget}", Color.red | Curses::A_BOLD)]
+    end
+
     ##
     # Formats tool arguments as compact key: value pairs
     # suitable for the status line.  Strings are quoted and
@@ -82,7 +109,7 @@ class LLM::Repl
       props  = props.sort_by { tool.params.properties[_1].index }
       props  = props.filter_map { args[_1] ? "#{_1}: #{format_value(args[_1])}" : nil }
       result = props.join(", ")
-      result.size > max ? "#{result[0...max - 1]}…" : result
+      Node.width(result) > max ? "#{Node.slice(result, max - 1)}…" : result
     end
 
     ##
@@ -92,7 +119,7 @@ class LLM::Repl
     def format_value(value, max: 18)
       case value
       when String
-        value.size > max ? "#{value[0...max]}…".inspect : value.inspect
+        Node.width(value) > max ? "#{Node.slice(value, max)}…".inspect : value.inspect
       when Array
         items = value.take(2).map { format_value(_1, max: 10) }
         items << "…" if value.size > 2
@@ -103,7 +130,7 @@ class LLM::Repl
         "nil"
       else
         str = value.inspect
-        str.size > max ? "#{str[0...max]}…" : str
+        Node.width(str) > max ? "#{Node.slice(str, max)}…" : str
       end
     end
   end

data/lib/llm/{repl → console}/walker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
   # Walks through an array from the last element backward,
   # one step at a time. {#next} moves forward toward the end.