llm.rb 13.0.0 → 14.0.0

data/lib/llm/repl/status.rb

@@ -4,22 +4,31 @@ class LLM::Repl
   ##
   # The {LLM::Repl::Status LLM::Repl::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),
+  # or an Array of either. Attributes on nodes are applied when the
+  # window draws the status line.
   # @api private
   class Status
     ##
-    # @param [LLM::Agent] agent
+    # @param [LLM::Repl] repl
     # @return [LLM::Repl::Status]
-    def initialize(agent)
-      @agent = agent
-      @provider = agent.llm.name
-      @text = "idle"
+    def initialize(repl)
+      @agent = repl.agent
+      @provider = @agent.llm.name
+      @nodes = [Node.new("idle")]
     end
 
     ##
     # @return [String]
     def context_bar
       LLM::Repl::Bar.new(
-        used: @agent.usage.total_tokens,
+        ##
+        # After compaction the used context is unknown until the next
+        # response, so the bar renders an unknown state instead of a
+        # stale percentage.
+        used: @agent.compacted? ? nil : @agent.usage.total_tokens,
         total: @agent.context_window
       ).to_s
     end
@@ -30,12 +39,38 @@ class LLM::Repl
       "$#{@agent.cost}"
     end
 
+    ##
+    # Sets the status text.
+    # @param [String, LLM::Repl::Node, Array<String, LLM::Repl::Node>] value
+    # @return [Array<LLM::Repl::Node>]
+    def text=(value)
+      @nodes =
+        case value
+        when Node then [value]
+        when Array then value.map { |node| Node === node ? node : Node.new(node) }
+        else [Node.new(value)]
+        end
+    end
+
     ##
     # @return [String]
-    attr_accessor :text
+    def text
+      @nodes.map(&:text).join
+    end
 
     ##
     # @return [String]
     alias_method :to_s, :text
+
+    ##
+    # The nodes making up the status line.
+    # @return [Array<LLM::Repl::Node>]
+    def nodes
+      if @agent.compacted?
+        [Node.new("Context compacted")]
+      else
+        @nodes
+      end
+    end
   end
 end

data/lib/llm/repl/stream.rb

@@ -8,6 +8,10 @@ class LLM::Repl
   # tool returns.
   # @api private
   class Stream < LLM::Stream
+    ##
+    # @return [Hash<Symbol, LLM::Tool>]
+    attr_reader :tools
+
     ##
     # @param [LLM::Repl] repl
     # @return [LLM::Repl::Stream]
@@ -15,6 +19,7 @@ class LLM::Repl
       @repl = repl
       @_queue = queue
       @buffer = +""
+      @tools = {}
     end
 
     ##
@@ -30,26 +35,33 @@ class LLM::Repl
     # @param [LLM::Function] tool
     # @return [void]
     def on_tool_call(tool)
-      @_queue.push [:status, "#{tool.name}(#{format_args(tool)})"]
+      @tools[tool.name] = tool
+      @_queue.push [:status, [" ", lambda, " • #{tool.name}(#{format_args(tool)})"]]
     end
 
     ##
-    # @param [LLM::Function] _tool
+    # @param [LLM::Function] tool
     # @param [LLM::Function::Return] result
     # @return [void]
-    def on_tool_return(_tool, result)
-      @_queue.push [:status, @repl.thinking_text]
+    def on_tool_return(tool, result)
+      @tools.delete(tool.name)
     end
 
     ##
-    # Empty the accumulated buffer
+    # Clear the accumulated buffer
     # @return [void]
-    def empty!
+    def clear
       @buffer.clear
     end
 
     private
 
+    ##
+    # @return [LLM::Repl::Node]
+    def lambda
+      Node.new("λ", Curses::A_BOLD | Color.red)
+    end
+
     ##
     # Formats tool arguments as compact key: value pairs
     # suitable for the status line.  Strings are quoted and

data/lib/llm/repl/walker.rb

@@ -18,12 +18,13 @@ class LLM::Repl
     end
 
     ##
-    # @return [Object, nil]
+    # @return [Object, String, nil]
     def next
       if @items.empty?
         nil
       elsif @cursor >= @items.size - 1
-        @items[@cursor]
+        @cursor = @items.size
+        ""
       else
         @cursor += 1
         @items[@cursor]

data/lib/llm/repl/window.rb

@@ -11,22 +11,22 @@ class LLM::Repl
     attr_reader :status
 
     ##
-    # @return [LLM::Repl::Transcript]
-    attr_reader :transcript
+    # @return [LLM::Repl::Buffer]
+    attr_reader :buffer
 
     ##
     # @return [LLM::Repl::Input]
     attr_reader :input
 
     ##
-    # @param [LLM::Repl::Status] status
-    # @param [LLM::Repl::Transcript] transcript
-    # @param [LLM::Repl::Input] input
+    # @param [LLM::Repl] repl
+    #  A read-eval-print loop.
     # @return [LLM::Repl::Window]
-    def initialize(status, transcript, input)
-      @status = status
-      @transcript = transcript
-      @input = input
+    def initialize(repl)
+      @repl   = repl
+      @status = repl.status
+      @buffer = repl.buffer
+      @input  = repl.input
     end
 
     ##
@@ -34,6 +34,7 @@ class LLM::Repl
     # @return [void]
     def open
       Curses.init_screen
+      Color.enable
       Curses.cbreak
       Curses.noecho
       Curses.stdscr.keypad(true)
@@ -48,7 +49,7 @@ class LLM::Repl
     def redraw
       draw_status(offset: input.height + 1)
       draw_divider(offset: 5)
-      draw_transcript(offset: 0)
+      draw_buffer(offset: 0)
       draw_input
       Curses.refresh
     end
@@ -59,6 +60,12 @@ class LLM::Repl
       [Curses.lines - (input.height + 4), 1].max
     end
 
+    ##
+    # @return [Integer]
+    def columns
+      Curses.cols
+    end
+
     ##
     # @return [Object]
     def getch
@@ -86,27 +93,56 @@ class LLM::Repl
     ##
     # @return [void]
     def scroll_up
-      transcript.scroll_up(rows)
+      buffer.scroll_up(rows)
     end
 
     ##
     # @return [void]
     def scroll_down
-      transcript.scroll_down
+      buffer.scroll_down
     end
 
     ##
     # @return [void]
     def scroll_to_bottom
-      transcript.scroll_to_bottom
+      buffer.scroll_to_bottom
     end
 
     private
 
+    def draw_buffer(offset:)
+      rows = buffer.visible(self.rows)
+      rows.each.with_index(offset) do |row, index|
+        Curses.setpos(index, 0)
+        Curses.clrtoeol
+        Curses.setpos(index, gutter)
+        width = 0
+        row.each do |chunk|
+          remaining = buffer.width - width
+          break if remaining <= 0
+          text, attrs = chunk.text.to_s, chunk.attrs
+          clipped = text[0, remaining]
+          Curses.attron(attrs) if attrs
+          Curses.addstr(clipped)
+          Curses.attroff(attrs) if attrs
+          width += clipped.length
+        end
+      end
+      last_drawn = offset + rows.size
+      (last_drawn...self.rows).each do |line|
+        Curses.setpos(line, 0)
+        Curses.clrtoeol
+      end
+    end
+
     def draw_status(offset:)
       Curses.setpos(Curses.lines - offset, 0)
       Curses.clrtoeol
-      Curses.addstr(status.to_s)
+      status.nodes.each do |node|
+        Curses.attron(node.attrs) if node.attrs
+        Curses.addstr(node.text)
+        Curses.attroff(node.attrs) if node.attrs
+      end
       context = status.context_bar
       Curses.setpos(Curses.lines - offset, [(columns - context.length) / 2, 0].max)
       Curses.addstr(context)
@@ -132,29 +168,12 @@ class LLM::Repl
       Curses.setpos((Curses.lines - input.height) + line, col)
     end
 
-    def draw_transcript(offset:)
-      rows = transcript.visible(self.rows)
-      rows.each.with_index(offset) do |row, index|
-        Curses.setpos(index, 0)
-        Curses.clrtoeol
-        row.each do |chunk|
-          text, attrs = chunk.values_at(:text, :attrs)
-          Curses.attron(attrs) if attrs
-          Curses.addstr(text)
-          Curses.attroff(attrs) if attrs
-        end
-      end
-      last_drawn = offset + rows.size
-      (last_drawn...self.rows).each do |line|
-        Curses.setpos(line, 0)
-        Curses.clrtoeol
-      end
-    end
-
     ##
+    # 20% offset that occupies the left margin and
+    # helps center {LLM::Repl::Buffer LLM::Repl::Buffer}.
     # @return [Integer]
-    def columns
-      Curses.cols
+    def gutter
+      (columns * 0.2).floor
     end
   end
 end

data/lib/llm/repl.rb

@@ -15,18 +15,20 @@ module LLM
   # task correctly, or for it to correct course after a
   # mistake was made.
   class Repl
+    require_relative "repl/color"
     require_relative "repl/window"
     require_relative "repl/status"
-    require_relative "repl/transcript"
+    require_relative "repl/buffer"
     require_relative "repl/input"
     require_relative "repl/bar"
     require_relative "repl/stream"
+    require_relative "repl/node"
     require_relative "repl/markdown"
     require_relative "repl/command"
     require_relative "repl/walker"
 
     attr_reader :agent, :provider, :stream,
-                :status, :transcript, :input,
+                :status, :buffer, :input,
                 :window, :tools, :thread,
                 :name, :path
 
@@ -44,12 +46,13 @@ module LLM
     def initialize(agent:, name: nil, tools: [], skills: [], path: nil)
       @path = path
       @name = name || "agent"
+      @sender = "You"
       @agent = configure(agent:, path:)
       @provider = agent.llm.name
-      @status = Status.new(@agent)
-      @transcript = Transcript.new
       @input = Input.new(self, height: 3)
-      @window = Window.new(@status, @transcript, @input)
+      @buffer = Buffer.new(self)
+      @status = Status.new(self)
+      @window = Window.new(self)
       @thread = nil
       @queue = Queue.new
       @stream = Stream.new(self, @queue)
@@ -70,6 +73,7 @@ module LLM
     def start
       window.open do
         catch(:exit) do
+          write tree(agent.messages)
           loop do
             now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             case input.on_char(window, input.paste? ? window.read_paste : window.getch, now)
@@ -86,22 +90,32 @@ module LLM
     end
 
     ##
-    # @param [String] chars
+    # @param [String, Array] chars
     # @param [Object] attrs
+    # @param [Symbol] method (:append, :replace)
     # @return [void]
-    def write(chars, attrs = nil)
-      transcript.write(chars, attrs)
+    def write(chars, attrs = nil, method: :append)
+      buffer.write(chars, attrs, method:)
       window.redraw
     end
 
     ##
-    # @param [String] chars
+    # @param [String] user
+    # @param [String] content
     # @return [void]
-    def markdown(chars)
-      transcript.markdown(chars)
+    def write_message(user, content, method: :append)
+      buffer.write_message(user, content, method:)
       window.redraw
     end
 
+    ##
+    # Returns an AST
+    # @param [String] chars
+    # @return [Array<Node>]
+    def markdown(chars)
+      LLM::Repl::Markdown.new(chars, buffer.width).ast
+    end
+
     ##
     # @param [String] value
     # @return [void]
@@ -112,12 +126,41 @@ module LLM
 
     ##
     # @return [String]
-    def thinking_text
-      "thinking • Esc to cancel"
+    def think_text
+      " 🧠 • Thinking • Esc to cancel"
+    end
+
+    ##
+    # @return [String]
+    def connect_text
+      " 🌐 • Connecting • Esc to cancel"
+    end
+
+    ##
+    # Returns a label for the person who sent a message.
+    # @return [String]
+    def sender
+      @sender
     end
 
     private
 
+    ##
+    # @param [LLM::Buffer] messages
+    #  A message buffer
+    # @return [Array<Node>]
+    def tree(messages)
+      messages.flat_map do |message|
+        next if message.tool_call? || message.tool_return?
+        user = message.assistant? ? name : sender
+        [
+          Node.new("#{user}:\n", Curses::A_BOLD | Color.blue),
+          *markdown(message.content),
+          Node.new("\n\n")
+        ]
+      end.compact
+    end
+
     ##
     # @param [LLM::Agent] agent
     #  An agent
@@ -151,15 +194,14 @@ module LLM
       case on_text(text)
       in [:command, Command => command, Hash => parameters]
         command.call(**parameters)
-      in [:error, String => who, String => text]
-        write(who, Curses::A_BOLD)
-        write(text)
+        write("\n")
+      in [:error, String => user, String => text]
+        write_message(user, text)
+        write("\n")
       in [:input, String => text]
         window.scroll_to_bottom
-        status.text = thinking_text
-        write("user: ", Curses::A_BOLD)
-        markdown(text)
-        write("\n#{name}: ", Curses::A_BOLD)
+        status.text = connect_text
+        write_message(sender, markdown(text))
         @thread = Thread.new do
           @queue << [:start]
           agent.talk(text, tools:, stream:)
@@ -214,29 +256,29 @@ module LLM
         type, value = @queue.pop(true)
         case type
         when :start
-          transcript.start
-          stream.empty!
+          buffer.open
+          stream.clear
         when :stream
-          transcript.markdown(value, method: :replace)
+          status.text = think_text if stream.tools.empty?
+          write_message name, markdown(value), method: :replace
         when :status
           self.status = value
         when :done
           status.text = "idle"
-          write("\n\n")
-          transcript.finish
+          buffer.close
           @thread = nil
+          write("\n")
         when :cancel
+          stream.tools.clear
+          buffer.close
           status.text = "Idle"
-          write("\n\n#{name}: ", Curses::A_BOLD)
-          write("request cancelled!")
-          write("\n\n")
-          transcript.finish
+          write_message(name, "Request cancelled")
           @thread = nil
+          write("\n")
         when :error
-          # Do this better
           status.text = "error"
-          write("\nerror: #{value.message}\n", Curses::A_BOLD)
-          transcript.finish
+          write_message(name, "(#{value.class}): #{value.message}")
+          buffer.close
           @thread = nil
         end
       end

data/lib/llm/skill.rb

@@ -7,6 +7,11 @@ module LLM
   # Skills can expose themselves as normal {LLM::Tool LLM::Tool} classes through
   # {#to_tool}. This keeps skills on the same execution path as local tools.
   class Skill
+    ##
+    # @api private
+    File = ::File
+    private_constant :File
+
     ##
     # Load a skill from a directory.
     # @param [String, Pathname] path
@@ -63,8 +68,14 @@ module LLM
     # Load and parse the skill.
     # @return [LLM::Skill]
     def load!
-      path = ::File.join(@path, "SKILL.md")
-      parse(::File.read(path))
+      if File.file?(@path)
+        parse(File.read(@path))
+      elsif File.directory?(@path)
+        path = File.join(@path, "SKILL.md")
+        parse(File.read(path))
+      else
+        raise LLM::Error, "'#{@path}' is neither a file or directory"
+      end
       self
     end
 
@@ -103,7 +114,8 @@ module LLM
     end
 
     ##
-    # Returns true when a skill should inherit tools from its parent
+    # Returns true when a skill should inherit tools
+    # from its parent
     # @return [Boolean]
     def inherit_tools?
       @inherit_tools
@@ -138,7 +150,11 @@ module LLM
     def parse_tools(tools)
       case tools
       when String
-        tools == "inherit" ? [true, []] : raise_invalid_error!(tools)
+        case tools
+        when "inherit" then [true, []]
+        when "all", "*" then [false, LLM::Tool.registry]
+        else raise_invalid_error!(tools)
+        end
       when Array
         [false, [*@frontmatter.tools].map { LLM::Tool.find_by_name!(_1) }]
       when NilClass

data/lib/llm/stream.rb

@@ -128,7 +128,10 @@ module LLM
     ##
     # Called when a streamed tool call has been fully constructed.
     # A stream implementation may start tool execution here by pushing
-    # `@queue << tool.task(:thread)` onto {#queue}.
+    # `@queue << tool.task(:thread).tap(&:spawn)` onto {#queue} — `spawn`
+    # returns nil, so `tap` keeps the task while starting it. The task
+    # carries the context's guard, so it is checked before the tool runs —
+    # a blocked call yields its guard return without executing.
     # @param [LLM::Function] tool
     #  The parsed tool call.
     # @return [nil]
@@ -151,19 +154,17 @@ module LLM
 
     ##
     # Called before a context transformer rewrites a prompt.
-    # @param [LLM::Context] ctx
-    # @param [#call] transformer
+    # @param [LLM::Transformer] transformer
     # @return [nil]
-    def on_transform(ctx, transformer)
+    def on_transform(transformer)
       nil
     end
 
     ##
     # Called after a context transformer finishes rewriting a prompt.
-    # @param [LLM::Context] ctx
-    # @param [#call] transformer
+    # @param [LLM::Transformer] transformer
     # @return [nil]
-    def on_transform_finish(ctx, transformer)
+    def on_transform_finish(transformer)
       nil
     end
 

data/lib/llm/tool.rb

@@ -150,6 +150,35 @@ class LLM::Tool
     end
   end
 
+  ##
+  # Assign multiple tool properties at once.
+  # @example
+  #   class Tool < LLM::Tool
+  #     set name: "my-tool",
+  #         description: "my tool does this and that",
+  #         parameters: [
+  #           [:name, String , "this and that"],
+  #           [:age , Integer, "this and that"]
+  #         ],
+  #         required: %i[name],
+  #         defaults: {age: 42}
+  #   end
+  # @param [Hash] properties
+  # @return [void]
+  def self.set(properties)
+    properties.each do
+      if _1.to_s == "parameters"
+        _2.each { |attributes| parameter(*attributes) }
+      else
+        if respond_to?(_1)
+          public_send(_1, _2)
+        else
+          raise KeyError, "key not found: #{_1}"
+        end
+      end
+    end
+  end
+
   ##
   # Returns (or sets) the tool name
   # @param [String, nil] name The tool name

data/lib/llm/tools/{swap_text.rb → edit-file.rb}

@@ -2,11 +2,11 @@
 
 class LLM::Tool
   ##
-  # The {LLM::Tool::SwapText LLM::Tool::SwapText} class
+  # The {LLM::Tool::EditFile LLM::Tool::EditFile} class
   # implements a tool that can substitute one piece of
   # text for another piece of text in a given file.
-  class SwapText < self
-    name "swap-text"
+  class EditFile < self
+    name "edit-file"
     description "Replace an exact snippet in a file"
     parameter :path, String, "Path to file"
     parameter :before, String, "Exact text to replace"

data/lib/llm/tools/git.rb

@@ -26,6 +26,9 @@ class LLM::Tool
       command = spawn(action:, arguments:)
       wait(command:, timeout:)
       {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
+    rescue LLM::Interrupt
+      command.kill! if command&.running?
+      raise
     end
 
     private

data/lib/llm/tools/mkdir.rb

@@ -15,6 +15,9 @@ class LLM::Tool
     def call(path:)
       command = spawn(path:)
       {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
+    rescue LLM::Interrupt
+      command.kill! if command&.running?
+      raise
     end
 
     private

data/lib/llm/tools/rg.rb

@@ -27,6 +27,9 @@ class LLM::Tool
       command = spawn(patterns:, path:)
       wait(command:, timeout:)
       {ok: command.success?, stdout: command.stdout, stderr: command.stderr}
+    rescue LLM::Interrupt
+      command.kill! if command&.running?
+      raise
     end
 
     private