llm.rb 13.0.0 → 14.0.0

data/lib/llm/providers/openai.rb

@@ -146,17 +146,17 @@ module LLM
 
     ##
     # Returns the default model for chat completions
-    # @see https://platform.openai.com/docs/models/gpt-5.4-mini gpt-5.4-mini
+    # @see https://platform.openai.com/docs/models/gpt-5.6-luna gpt-5.6-luna
     # @return [String]
     def default_model
-      "gpt-5.4-mini"
+      "gpt-5.6-luna"
     end
 
     ##
     # @param [LLM::Function] fn
     # @return [Hash]
     def adapt_function(fn)
-      params = fn.params || {type: "object", properties: {}}
+      params = fn.params.to_h
       {
         type: "function", name: fn.name,
         function: {name: fn.name, description: fn.description, parameters: params}
@@ -230,20 +230,13 @@ module LLM
     end
 
     def build_complete_request(prompt, params, role)
-      messages = build_complete_messages(prompt, params, role)
+      messages = build_messages(prompt, params, role)
       body = LLM.json.dump({messages: adapt(messages, mode: :complete).flatten}.merge!(params))
       req = LLM::Transport::Request.post(completions_path, headers)
       transport.set_body_stream(req, StringIO.new(body))
       [req, messages]
     end
 
-    def build_complete_messages(prompt, params, role)
-      if LLM::Prompt === prompt
-        [*(params.delete(:messages) || []), *prompt]
-      else
-        [*(params.delete(:messages) || []), Message.new(role, prompt)]
-      end
-    end
 
     def extract_user_input(messages, fallback:)
       message = messages.reverse.find(&:user?) || messages.last

data/lib/llm/repl/bar.rb

@@ -17,7 +17,8 @@ class LLM::Repl
     FREE = " "
 
     ##
-    # @param [Integer] used
+    # @param [Integer, nil] used
+    #  The used context, or nil when it is unknown (eg after compaction).
     # @param [Integer] total
     # @param [Integer] width
     # @return [LLM::Repl::Bar]
@@ -36,11 +37,11 @@ class LLM::Repl
     private
 
     ##
-    # @param [Integer] used
+    # @param [Integer, nil] used
     # @param [Integer] total
     # @return [[String, Integer]]
     def remainder(used, total)
-      return ["???", width] if total <= 0
+      return ["???", width] if used.nil? || total <= 0
       diff = total - used
       return ["0%", 0] if diff <= 0
       remaining = (diff.fdiv(total) * 100).round(2)

data/lib/llm/repl/{transcript.rb → buffer.rb}

@@ -14,12 +14,14 @@ class LLM::Repl
   # It also maintains a cursor that tracks the active row
   # by its index number. The streaming path reuses a single
   # row by overwriting its contents repeatedly.
-  class Transcript
-    WIDTH = 80
-
+  class Buffer
     ##
-    # @return [LLM::Repl::Transcript]
-    def initialize
+    # @param [LLM::Repl] repl
+    #  An instance of {LLM::Repl LLM::Repl}.
+    # @return [LLM::Repl::Buffer]
+    def initialize(repl)
+      @repl   = repl
+      @window = repl.window
       @rows = [[]]
       @cursor = nil
       @snapshot = nil
@@ -27,37 +29,45 @@ class LLM::Repl
     end
 
     ##
-    # @param [String] chars
+    # @param [String, Array] chars
     # @param [Object] attrs
     # @param [Symbol] method
     # @return [void]
     def write(chars, attrs = nil, method: :append)
-      chunks = [{text: chars.to_s, attrs:}.compact]
+      case chars
+      when Array then chunks = chars
+      else chunks = [Node.new(chars.to_s, attrs)]
+      end
       self.method(method).call(chunks)
     end
 
     ##
-    # Appends Markdown to the transcript.
-    # @param [String] chars
+    # @param [String] user
+    # @param [String, Array] content
     # @param [Symbol] method
     # @return [void]
-    def markdown(chars, method: :append)
-      chunks = LLM::Repl::Markdown.new(chars, WIDTH).ast
-      self.method(method).call(chunks)
+    def write_message(user, content, method: :append)
+      chunks = [Node.new("#{user}:\n", Curses::A_BOLD | Color.blue)]
+      case content
+      when Array then chunks.concat(content)
+      else chunks.push(Node.new(content))
+      end
+      chunks.push(Node.new("\n\n"))
+      write(chunks, method:)
     end
 
     ##
-    # Start the transcript.
+    # Open the buffer.
     # @return [void]
-    def start
+    def open
       @cursor = @rows.size - 1
       @snapshot = @rows.map(&:dup)
     end
 
     ##
-    # Finish the transcript.
+    # Close the buffer.
     # @return [void]
-    def finish
+    def close
       @cursor = nil
       @snapshot = nil
     end
@@ -81,6 +91,15 @@ class LLM::Repl
       @offset = 0
     end
 
+    ##
+    # The width of the centered content area -
+    # with 20% on each side. The rest makes up
+    # the width of the buffer.
+    # @return [Integer]
+    def width
+      (Curses.cols * 0.6).floor
+    end
+
     ##
     # @param [Integer] height
     # @return [Array<String>]
@@ -93,9 +112,13 @@ class LLM::Repl
 
     private
 
+    ##
+    # @api private
+    attr_reader :repl, :window
+
     ##
     # Appends a new row
-    # @param [Array<{text: String, attrs?: Integer}>] chunks
+    # @param [Array<Node>] chunks
     #  One or more chunks.
     # @return [void]
     def append(chunks)
@@ -104,29 +127,46 @@ class LLM::Repl
 
     ##
     # Replaces the content of the active row
-    # @param [Array<{text: String, attrs?: Integer}>] chunks
+    # @param [Array<Node>] chunks
     #  One or more chunks.
     # @return [void]
     def replace(chunks)
       @rows = @snapshot.map(&:dup)
-      append(chunks)
+      chunks.each { wrap(_1, @rows) }
     end
 
     ##
-    # Given a chunk this method wraps text at
-    # around 80 columns: a new row starts when
-    # the current character is " " and the sum
-    # of all characters in that row is greater
-    # than 80 columns.
+    # Given a chunk this method wraps text to the buffer's
+    # width. The text is split into words; a word that does
+    # not fit on the current row moves to the next. Only a
+    # single word longer than the whole width is hard-broken,
+    # so text is never clipped by the window.
     def wrap(chunk, rows)
       attrs = chunk[:attrs]
-      chunk[:text].to_s.each_char do |char|
-        if char == "\n"
-          rows << []
-        elsif char == " " and sum(rows.last) >= WIDTH
+      chunk[:text].to_s.scan(/\n|[^\s]+|\s+/) do |token|
+        if token == "\n"
           rows << []
+        elsif token.match?(/\s/)
+          if sum(rows.last) + token.length <= width
+            rows.last << Node.new(token, attrs)
+          end
+        elsif sum(rows.last) + token.length > width
+          if sum(rows.last) == 0
+            ##
+            # A single word wider than the row: break it
+            # every width characters.
+            token.scan(/.{1,#{width}}/).each do |piece|
+              rows.last << Node.new(piece, attrs)
+              if sum(rows.last) >= width
+                rows << []
+              end
+            end
+          else
+            rows << []
+            rows.last << Node.new(token, attrs)
+          end
         else
-          rows.last << {text: char, attrs:}.compact
+          rows.last << Node.new(token, attrs)
         end
       end
     end

data/lib/llm/repl/color.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class LLM::Repl
+  ##
+  # The {LLM::Repl::Color LLM::Repl::Color} module returns
+  # bitmasks that are understood as colors by the Curses
+  # library. They can be bitwise OR'ed with other attributes,
+  # such as Curses::A_BOLD.
+  module Color
+    ##
+    # Enable color and initialize 8 color pairs.
+    # @return [void]
+    def self.enable
+      Curses.start_color
+      ##
+      # The first argument is the color pairs ID, and
+      # it is mapped back to a bitmask via {Curses.color_pair}.
+      # The second argument is the foreground color, and
+      # the third argument is the background color.
+      Curses.init_pair(1, Curses::COLOR_BLACK   , Curses::COLOR_WHITE)
+      Curses.init_pair(2, Curses::COLOR_BLUE    , Curses::COLOR_BLACK)
+      Curses.init_pair(3, Curses::COLOR_CYAN    , Curses::COLOR_BLACK)
+      Curses.init_pair(4, Curses::COLOR_GREEN   , Curses::COLOR_BLACK)
+      Curses.init_pair(5, Curses::COLOR_MAGENTA , Curses::COLOR_BLACK)
+      Curses.init_pair(6, Curses::COLOR_RED     , Curses::COLOR_BLACK)
+      Curses.init_pair(7, Curses::COLOR_WHITE   , Curses::COLOR_BLACK)
+      Curses.init_pair(8, Curses::COLOR_YELLOW  , Curses::COLOR_BLACK)
+    end
+
+    ##
+    # @return [Integer]
+    def self.black
+      Curses.color_pair(1)
+    end
+
+    ##
+    # @return [Integer]
+    def self.blue
+      Curses.color_pair(2)
+    end
+
+    ##
+    # @return [Integer]
+    def self.cyan
+      Curses.color_pair(3)
+    end
+
+    ##
+    # @return [Integer]
+    def self.green
+      Curses.color_pair(4)
+    end
+
+    ##
+    # @return [Integer]
+    def self.magneta
+      Curses.color_pair(5)
+    end
+
+    ##
+    # @return [Integer]
+    def self.red
+      Curses.color_pair(6)
+    end
+
+    ##
+    # @return [Integer]
+    def self.white
+      Curses.color_pair(7)
+    end
+
+    ##
+    # @return [Integer]
+    def self.yellow
+      Curses.color_pair(8)
+    end
+  end
+end

data/lib/llm/repl/command.rb

@@ -176,12 +176,19 @@ class LLM::Repl
     end
 
     ##
-    # Write a string to the transcript
-    # @param [String] str
+    # Write a string to the buffer
+    # @param [String] content
+    # @return [void]
+    def write(content)
+      write_message "command(#{self.class.name})", content
+    end
+
+    ##
+    # @param [String] user
+    # @param [String] content
     # @return [void]
-    def write(str, who: "command(#{self.class.name}): ")
-      @repl.write(who, Curses::A_BOLD)
-      @repl.write(str)
+    def write_message(user, content)
+      @repl.write_message(user, content)
     end
 
     ##

data/lib/llm/repl/commands/compact.rb

@@ -17,9 +17,9 @@ class LLM::Repl
     ##
     # @return [void]
     def call(n: 128)
-      write("compact in progress\n")
+      write "compact in progress"
       compactor.call(keep: n)
-      write("compact complete\n\n")
+      write "compact complete"
     end
 
     private

data/lib/llm/repl/commands/help.rb

@@ -11,13 +11,11 @@ class LLM::Repl
     # @return [void]
     def call(name: nil)
       if name.nil?
-        write("\n#{self.class.help}\n\n")
+        write(self.class.help)
       elsif command = LLM::Command.find_by(name:)
-        write("\n#{command.help}\n\n")
+        write(command.help)
       else
-        write "\nNo help for #{name} was found" \
-              "\nThat command doesn't exist." \
-              "\n\n"
+        write "no help for #{name} was found"
       end
     end
   end

data/lib/llm/repl/input/char.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class LLM::Repl::Input
+  ##
+  # A single editable character of the input.
+  class Char
+    ##
+    # @param [String] char
+    # @return [LLM::Repl::Input::Char]
+    def initialize(char)
+      @char = char
+    end
+
+    ##
+    # Returns true when both strings returned
+    # by the #{to_s} method are considered equal
+    # by {String#==}.
+    # @param [#to_s] other
+    # @return [Boolean]
+    def ==(other)
+      to_s == other.to_s
+    end
+    alias_method :eql?, :==
+
+    ##
+    # Returns a hash consistent with {#eql?},
+    # so equal chars behave as the same key in
+    # a Hash or Set.
+    # @return [Integer]
+    def hash
+      to_s.hash
+    end
+
+    ##
+    # @return [Boolean]
+    def empty?
+      @char == ""
+    end
+
+    ##
+    # @return [String]
+    def to_s
+      @char.dup
+    end
+  end
+end

data/lib/llm/repl/input/row.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class LLM::Repl::Input
+  ##
+  # One line of the input. `chars` holds the editable characters.
+  # `break_type` records how this line got started: an auto-wrap
+  # (`:space`) or a real newline (`:newline`). The first row has no
+  # break type. It decides how the input is flattened on {Input#take}.
+  class Row
+    ##
+    # @return [Array<Input::Char>]
+    attr_reader :chars
+
+    ##
+    # @return [Symbol, nil]
+    #  `:space` or `:newline`, or nil for the first row.
+    attr_accessor :break_type
+
+    ##
+    # @param [Symbol, nil] break_type
+    #  How this line was started.
+    def initialize(break_type = nil)
+      @chars = []
+      @break_type = break_type
+    end
+
+    ##
+    # @return [String]
+    def to_s
+      chars.map(&:to_s).join
+    end
+
+    ##
+    # @return [Boolean]
+    def empty?
+      chars.empty?
+    end
+  end
+end