brute 1.0.0 → 2.0.0

data/lib/brute/tools/delegate.rb

@@ -5,54 +5,66 @@ require "brute"
 
 module Brute
   module Tools
-    class Delegate < LLM::Tool
-      name "delegate"
+    class Delegate < RubyLLM::Tool
       description "Delegate a research or analysis task to a specialist sub-agent. " \
                   "The sub-agent can read files and search but cannot write or execute commands. " \
                   "Use for code analysis, understanding patterns, or gathering information."
 
-      param :task, String, "A clear, detailed description of the research task", required: true
+      param :task, type: 'string', desc: "A clear, detailed description of the research task", required: true
 
-      def call(task:)
-        provider = Brute.provider
-        sub = LLM::Context.new(provider, tools: [FSRead, FSSearch])
+      def name; "delegate"; end
 
-        prompt = sub.prompt do
-          system "You are a research agent. Analyze code, explain patterns, and answer questions. " \
-                 "You have read-only access to the filesystem. Be thorough and precise."
-          user task
-        end
+      MAX_ROUNDS = 10
 
-        # Run a manual tool loop (max 10 rounds)
-        res = sub.talk(prompt)
-        rounds = 0
-        while sub.functions.any? && rounds < 10
-          res = sub.talk(sub.functions.map(&:call))
-          rounds += 1
+      def execute(task:)
+        provider = Brute.provider
+        llm = provider.ruby_llm_provider
+        model_id = provider.default_model
+        model = Brute::Middleware::ModelRef.new(model_id, 16_384)
+
+        sub_tools = { read: FSRead.new, fs_search: FSSearch.new }
+
+        messages = [
+          RubyLLM::Message.new(
+            role: :system,
+            content: "You are a research agent. Analyze code, explain patterns, and answer questions. " \
+                     "You have read-only access to the filesystem. Be thorough and precise."
+          ),
+          RubyLLM::Message.new(role: :user, content: task),
+        ]
+
+        response = nil
+        MAX_ROUNDS.times do
+          response = llm.complete(messages, tools: sub_tools, temperature: nil, model: model)
+          messages << response
+
+          break unless response.tool_call?
+
+          response.tool_calls.each_value do |tc|
+            tool = sub_tools[tc.name.to_sym]
+            result = if tool
+                       tool.call(tc.arguments)
+                     else
+                       { error: "Unknown tool: #{tc.name}" }
+                     end
+            content = result.is_a?(String) ? result : result.to_s
+            messages << RubyLLM::Message.new(role: :tool, content: content, tool_call_id: tc.id)
+          end
         end
 
-        {result: extract_content(res, sub)}
+        { result: extract_content(response, messages) }
       end
 
       private
 
       # Safely extract text content from the sub-agent response.
-      #
-      # When the LLM returns only tool calls (no text content block),
-      # res.content raises NoMethodError because the response adapter's
-      # choices array is empty (it only maps over text blocks), or
-      # returns nil when the response has no text. Fall back to the
-      # last assistant text in the conversation history.
-      def extract_content(res, context)
-        text = begin
-          res.content
-        rescue NoMethodError
-          nil
-        end
+      def extract_content(response, messages)
+        text = response&.content
         return text if text.is_a?(::String) && !text.empty?
 
-        last_assistant = context.messages.to_a
-          .select(&:assistant?)
+        # Fall back to last assistant text in the conversation history
+        last_assistant = messages
+          .select { |m| m.role == :assistant }
           .reverse
           .find { |m| m.content.is_a?(::String) && !m.content.empty? }
         last_assistant&.content || "(sub-agent completed but produced no text response)"
@@ -65,54 +77,33 @@ test do
   require_relative "../../../spec/support/mock_provider"
   require_relative "../../../spec/support/mock_response"
 
-  FakeMsg = Struct.new(:role, :content) do
-    def assistant?; role == :assistant; end
-  end
-
-  def fake_context(messages)
-    msgs_obj = Object.new
-    msgs_obj.define_singleton_method(:to_a) { messages }
-    ctx = Object.new
-    ctx.define_singleton_method(:messages) { msgs_obj }
-    ctx
-  end
-
   delegate = Brute::Tools::Delegate.new
 
   it "returns content when response has text" do
-    res = MockResponse.new(content: "analysis complete")
-    delegate.send(:extract_content, res, fake_context([])).should == "analysis complete"
+    res = RubyLLM::Message.new(role: :assistant, content: "analysis complete")
+    delegate.send(:extract_content, res, []).should == "analysis complete"
   end
 
-  it "falls back to last assistant text on NoMethodError" do
-    bad_res = Object.new
-    bad_res.define_singleton_method(:content) { raise NoMethodError }
-    ctx = fake_context([FakeMsg.new(:user, "input"), FakeMsg.new(:assistant, "found the answer")])
-    delegate.send(:extract_content, bad_res, ctx).should == "found the answer"
+  it "falls back to last assistant text on nil content" do
+    res = RubyLLM::Message.new(role: :assistant, content: "")
+    msgs = [
+      RubyLLM::Message.new(role: :user, content: "input"),
+      RubyLLM::Message.new(role: :assistant, content: "found the answer"),
+    ]
+    delegate.send(:extract_content, res, msgs).should == "found the answer"
   end
 
   it "returns fallback when no assistant messages exist" do
-    bad_res = Object.new
-    bad_res.define_singleton_method(:content) { raise NoMethodError }
-    delegate.send(:extract_content, bad_res, fake_context([])).should == "(sub-agent completed but produced no text response)"
+    res = RubyLLM::Message.new(role: :assistant, content: "")
+    delegate.send(:extract_content, res, []).should == "(sub-agent completed but produced no text response)"
   end
 
   it "skips assistant messages with empty content" do
-    bad_res = Object.new
-    bad_res.define_singleton_method(:content) { raise NoMethodError }
-    ctx = fake_context([FakeMsg.new(:assistant, "real answer"), FakeMsg.new(:assistant, "")])
-    delegate.send(:extract_content, bad_res, ctx).should == "real answer"
-  end
-
-  it "falls back to last assistant on nil content" do
-    nil_res = Struct.new(:content).new(nil)
-    ctx = fake_context([FakeMsg.new(:assistant, "previous answer")])
-    delegate.send(:extract_content, nil_res, ctx).should == "previous answer"
-  end
-
-  it "falls back to last assistant on empty string content" do
-    empty_res = Struct.new(:content).new("")
-    ctx = fake_context([FakeMsg.new(:assistant, "previous answer")])
-    delegate.send(:extract_content, empty_res, ctx).should == "previous answer"
+    res = RubyLLM::Message.new(role: :assistant, content: "")
+    msgs = [
+      RubyLLM::Message.new(role: :assistant, content: "real answer"),
+      RubyLLM::Message.new(role: :assistant, content: ""),
+    ]
+    delegate.send(:extract_content, res, msgs).should == "real answer"
   end
 end

data/lib/brute/tools/fs_patch.rb

@@ -2,20 +2,22 @@
 
 require "bundler/setup"
 require "brute"
+require "brute/tools"
 
 module Brute
   module Tools
-    class FSPatch < LLM::Tool
-      name 'patch'
+    class FSPatch < RubyLLM::Tool
       description 'Replace a specific string in a file. The old_string must match exactly ' \
                   '(including whitespace and indentation). Always read a file before patching it.'
 
-      param :file_path, String, 'Path to the file to patch', required: true
-      param :old_string, String, 'The exact text to find and replace', required: true
-      param :new_string, String, 'The replacement text', required: true
-      param :replace_all, Boolean, 'Replace all occurrences (default: false)'
+      param :file_path, type: 'string', desc: 'Path to the file to patch', required: true
+      param :old_string, type: 'string', desc: 'The exact text to find and replace', required: true
+      param :new_string, type: 'string', desc: 'The replacement text', required: true
+      param :replace_all, type: 'boolean', desc: 'Replace all occurrences (default: false)', required: false
 
-      def call(file_path:, old_string:, new_string:, replace_all: false)
+      def name; "patch"; end
+
+      def execute(file_path:, old_string:, new_string:, replace_all: false)
         path = File.expand_path(file_path)
         Brute::Queue::FileMutationQueue.serialize(path) do
           raise "File not found: #{path}" unless File.exist?(path)

data/lib/brute/tools/fs_read.rb

@@ -1,41 +1,254 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
+require "brute/tools"
+require "brute/truncation"
 
 module Brute
   module Tools
-    class FSRead < LLM::Tool
-      name "read"
+    # Existing features (ref: opencode read tool):
+    #
+    # 1. Default line limit — cap reads at 2000 lines when no start_line/end_line
+    #    given, instead of reading the entire file.
+    # 2. Byte cap — stop reading when cumulative output exceeds 50 KB (MAX_BYTES).
+    #    Whichever limit (lines or bytes) is hit first wins.
+    # 3. Per-line truncation — truncate individual lines longer than 2000 chars
+    #    with a suffix like "... (line truncated to 2000 chars)".
+    # 4. Pagination hint — when output is truncated, append a hint:
+    #    "(Showing lines 1-N of M. Use start_line=N+1 to continue.)"
+    #    When reading completes, append "(End of file - total N lines)".
+    # 5. Binary file detection — read first 4 KB sample, check for null bytes
+    #    and known binary extensions (.zip, .exe, .so, .pyc, etc.).
+    #    Reject with "Cannot read binary file: <path>".
+    # 6. Directory listing — when file_path points to a directory, list entries
+    #    (paginated, respecting limit) instead of raising an error.
+    # 7. File-not-found suggestions — on miss, scan the parent directory for
+    #    similar names and suggest "Did you mean...?" candidates.
+    # 8. Return a plain string instead of a Hash — avoids the .to_s repr
+    #    bloat when ToolCall coerces the result for the LLM message.
+    #
+    class FSRead < RubyLLM::Tool
       description "Read the contents of a file. Returns file content with line numbers. " \
                   "Use start_line/end_line for partial reads of large files."
 
-      param :file_path, String, "Absolute or relative path to the file to read", required: true
-      param :start_line, Integer, "Starting line number (1-indexed). Omit to read from beginning"
-      param :end_line, Integer, "Ending line number (inclusive). Omit to read to end"
+      param :file_path, type: 'string', desc: "Absolute or relative path to the file to read", required: true
+      param :start_line, type: 'integer', desc: "Starting line number (1-indexed). Omit to read from beginning", required: false
+      param :end_line, type: 'integer', desc: "Ending line number (inclusive). Omit to read to end", required: false
+
+      def name; "read"; end
 
-      def call(file_path:, start_line: nil, end_line: nil)
+      BINARY_EXTENSIONS = %w[.zip .exe .so .pyc .pyo .dll .dylib .bin .o .a .tar .gz .bz2 .xz .7z .rar .jar .war .class .png .jpg .jpeg .gif .bmp .ico .pdf .woff .woff2 .ttf .eot .mp3 .mp4 .avi .mov .flv .wmv .db .sqlite .sqlite3].freeze
+      DEFAULT_LINE_CAP = 2000
+      MAX_BYTES = Brute::Truncation::MAX_BYTES
+      MAX_LINE_LENGTH = Brute::Truncation::MAX_LINE_LENGTH
+
+      def execute(file_path:, start_line: nil, end_line: nil)
         path = File.expand_path(file_path)
-        raise "File not found: #{path}" unless File.exist?(path)
+
+        # Directory listing
+        return list_directory(path) if File.directory?(path)
+
+        # File-not-found suggestions
+        unless File.exist?(path)
+          suggestions = find_similar(path)
+          msg = "File not found: #{path}"
+          msg += ". Did you mean: #{suggestions.join(', ')}?" if suggestions.any?
+          raise msg
+        end
+
         raise "Not a file: #{path}" unless File.file?(path)
 
+        # Binary file detection
+        ext = File.extname(path).downcase
+        raise "Cannot read binary file: #{path}" if BINARY_EXTENSIONS.include?(ext)
+
+        sample = File.binread(path, 4096) || ""
+        raise "Cannot read binary file: #{path}" if sample.include?("\x00")
+
         lines = File.readlines(path)
+        total = lines.size
         first = start_line ? [start_line - 1, 0].max : 0
-        last = end_line ? [end_line - 1, lines.size - 1].min : lines.size - 1
+
+        # Apply default line cap when no explicit range given
+        default_last = end_line ? [end_line - 1, total - 1].min : [first + DEFAULT_LINE_CAP - 1, total - 1].min
+        last = default_last
 
         selected = lines[first..last] || []
-        numbered = selected.each_with_index.map do |line, i|
-          "#{first + i + 1}\t#{line}"
+
+        # Per-line truncation + byte cap
+        numbered = []
+        bytes = 0
+        selected.each_with_index do |line, i|
+          truncated_line = Brute::Truncation.truncate_line(line, max: MAX_LINE_LENGTH)
+          numbered_line = "#{first + i + 1}\t#{truncated_line}"
+          break if bytes + numbered_line.bytesize > MAX_BYTES
+          numbered << numbered_line
+          bytes += numbered_line.bytesize
+        end
+
+        actual_last = first + numbered.size - 1
+        content = numbered.join
+        truncated = (actual_last < total - 1) && end_line.nil?
+
+        if truncated
+          content + "\n(Showing lines #{first + 1}-#{actual_last + 1} of #{total}. Use start_line=#{actual_last + 2} to continue.)"
+        else
+          content
+        end
+      end
+
+      private
+
+      def list_directory(path)
+        entries = Dir.entries(path).reject { |e| e.start_with?(".") }.sort
+        total = entries.size
+        capped = entries.first(DEFAULT_LINE_CAP)
+        result = capped.map do |entry|
+          full = File.join(path, entry)
+          type = File.directory?(full) ? "dir" : "file"
+          "#{entry} (#{type})"
+        end.join("\n")
+
+        if total > DEFAULT_LINE_CAP
+          result += "\n(Showing #{DEFAULT_LINE_CAP} of #{total} entries)"
+        end
+        result
+      end
+
+      def find_similar(path)
+        dir = File.dirname(path)
+        target = File.basename(path)
+        return [] unless File.directory?(dir)
+
+        entries = Dir.entries(dir).reject { |e| e.start_with?(".") }
+        entries.select { |e| levenshtein(e.downcase, target.downcase) <= 3 }
+               .sort_by { |e| levenshtein(e.downcase, target.downcase) }
+               .first(3)
+      end
+
+      def levenshtein(a, b)
+        m, n = a.length, b.length
+        d = Array.new(m + 1) { |i| i }
+        (1..n).each do |j|
+          prev = d[0]
+          d[0] = j
+          (1..m).each do |i|
+            cost = a[i - 1] == b[j - 1] ? 0 : 1
+            temp = d[i]
+            d[i] = [d[i] + 1, d[i - 1] + 1, prev + cost].min
+            prev = temp
+          end
         end
+        d[m]
+      end
+    end
+  end
+end
+
+test do
+  require "tmpdir"
+
+  it "reads a file without error" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.txt")
+      File.write(path, "line1\nline2\nline3\n")
+      result = Brute::Tools::FSRead.new.call(file_path: path)
+      result.should =~ /line1/
+    end
+  end
+
+  it "reads a range without error" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.txt")
+      File.write(path, "a\nb\nc\nd\ne\n")
+      result = Brute::Tools::FSRead.new.call(file_path: path, start_line: 2, end_line: 4)
+      result.should =~ /2\tb/
+    end
+  end
+
+  it "raises on missing file" do
+    lambda { Brute::Tools::FSRead.new.call(file_path: "/nonexistent/file.txt") }.should.raise
+  end
+
+  it "returns a String, not a Hash" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.txt")
+      File.write(path, "hello\n")
+      Brute::Tools::FSRead.new.call(file_path: path).should.be.kind_of(String)
+    end
+  end
+
+  it "caps output at 2000 lines by default" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "big.txt")
+      File.write(path, "x\n" * 3000)
+      result = Brute::Tools::FSRead.new.call(file_path: path)
+      result.lines.size.should.be < 2100
+    end
+  end
+
+  it "rejects binary files" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "binary.bin")
+      File.binwrite(path, "\x00\x01\x02\x03" * 1000)
+      lambda { Brute::Tools::FSRead.new.call(file_path: path) }.should.raise
+    end
+  end
+
+  it "includes a pagination hint when truncated" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "big.txt")
+      File.write(path, "x\n" * 3000)
+      result = Brute::Tools::FSRead.new.call(file_path: path)
+      result.should =~ /start_line/
+    end
+  end
+
+  # --- Byte cap ---
+
+  it "stops reading when output exceeds 50 KB" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "big.txt")
+      # Each line ~200 bytes, 500 lines = ~100 KB > 50 KB
+      File.write(path, ("z" * 200 + "\n") * 500)
+      result = Brute::Tools::FSRead.new.call(file_path: path)
+      result.bytesize.should.be < 55_000
+    end
+  end
+
+  # --- Per-line truncation ---
+
+  it "truncates lines longer than 2000 chars" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "longlines.txt")
+      File.write(path, "x" * 3000 + "\nshort\n")
+      result = Brute::Tools::FSRead.new.call(file_path: path)
+      result.lines.first.size.should.be < 2100
+    end
+  end
+
+  # --- Directory listing ---
+
+  it "lists directory entries instead of raising" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "a.txt"), "a")
+      File.write(File.join(dir, "b.rb"), "b")
+      result = Brute::Tools::FSRead.new.call(file_path: dir)
+      result.should =~ /a\.txt/
+      result.should =~ /b\.rb/
+    end
+  end
+
+  # --- File-not-found suggestions ---
 
-        {
-          file_path: path,
-          total_lines: lines.size,
-          showing: "#{first + 1}-#{last + 1}",
-          content: numbered.join,
-        }
+  it "suggests similar files on miss" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "config.yml"), "x")
+      begin
+        Brute::Tools::FSRead.new.call(file_path: File.join(dir, "conifg.yml"))
+      rescue => e
+        e.message.should =~ /did you mean/i
       end
     end
   end

data/lib/brute/tools/fs_remove.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
-
+require "bundler/setup"
+require "brute"
+require "brute/tools"
 require "fileutils"
 
 module Brute
   module Tools
-    class FSRemove < LLM::Tool
-      name "remove"
+    class FSRemove < RubyLLM::Tool
       description "Remove a file or empty directory."
 
-      param :path, String, "Path to the file or directory to remove", required: true
+      param :path, type: 'string', desc: "Path to the file or directory to remove", required: true
+
+      def name; "remove"; end
 
-      def call(path:)
+      def execute(path:)
         target = File.expand_path(path)
         Brute::Queue::FileMutationQueue.serialize(target) do
           raise "Path not found: #{target}" unless File.exist?(target)

data/lib/brute/tools/fs_search.rb

@@ -1,31 +1,44 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
-
+require "bundler/setup"
+require "brute"
+require "brute/tools"
+require "brute/truncation"
 require "open3"
 
 module Brute
   module Tools
-    class FSSearch < LLM::Tool
-      name "fs_search"
+    # Existing features (ref: opencode grep tool):
+    #
+    # 1. Global result cap — limit total matches to 100 across all files.
+    # 2. Per-line truncation — truncate individual match lines longer than
+    #    2000 chars via rg --max-columns with preview.
+    # 3. Structured truncation message — when results are capped, append:
+    #    "(Results truncated: showing 100 of N matches. Consider a more
+    #    specific path or pattern.)"
+    # 4. Sort results by file mtime — most-recently-modified files first,
+    #    so the LLM sees the most relevant matches first.
+    # 5. Return a plain string instead of a Hash.
+    # 6. Align output cap with universal truncation (2000 lines / 50 KB).
+    #
+    class FSSearch < RubyLLM::Tool
       description "Search file contents using ripgrep (regex), or find files by glob pattern. " \
                   "Returns matching lines with file paths and line numbers."
 
-      param :pattern, String, "Regex pattern to search for in file contents", required: true
-      param :path, String, "Directory to search in (defaults to current working directory)"
-      param :glob, String, "File glob filter, e.g. '*.rb', '*.{js,ts}'"
-      param :ignore_case, Boolean, "Case-insensitive search (default: false)"
+      param :pattern, type: 'string', desc: "Regex pattern to search for in file contents", required: true
+      param :path, type: 'string', desc: "Directory to search in (defaults to current working directory)", required: false
+      param :glob, type: 'string', desc: "File glob filter, e.g. '*.rb', '*.{js,ts}'", required: false
+      param :ignore_case, type: 'boolean', desc: "Case-insensitive search (default: false)", required: false
 
-      MAX_OUTPUT = 40_000
+      def name; "fs_search"; end
 
-      def call(pattern:, path: nil, glob: nil, ignore_case: false)
+      MAX_TOTAL_MATCHES = 100
+
+      def execute(pattern:, path: nil, glob: nil, ignore_case: false)
         dir = File.expand_path(path || Dir.pwd)
         raise "Directory not found: #{dir}" unless File.directory?(dir)
 
-        cmd = ["rg", "--line-number", "--max-count=100", "--max-columns=200"]
+        cmd = ["rg", "--line-number", "--max-columns=2000", "--max-columns-preview", "--sortr=modified"]
         cmd << "--ignore-case" if ignore_case
         cmd += ["--glob", glob] if glob
         cmd << pattern
@@ -34,10 +47,79 @@ module Brute
         stdout, stderr, status = Open3.capture3(*cmd)
 
         output = stdout.empty? ? stderr : stdout
-        output = output[0...MAX_OUTPUT] + "\n...(truncated)" if output.size > MAX_OUTPUT
 
-        {results: output, exit_code: status.exitstatus, truncated: output.size > MAX_OUTPUT}
+        # Global cap at MAX_TOTAL_MATCHES lines
+        lines = output.lines
+        total_matches = lines.size
+        if total_matches > MAX_TOTAL_MATCHES
+          output = lines.first(MAX_TOTAL_MATCHES).join
+          output += "\n(Results truncated: showing 100 of #{total_matches} matches. Consider a more specific path or pattern.)"
+        end
+
+        Brute::Truncation.truncate(output)
       end
     end
   end
 end
+
+test do
+  require "tmpdir"
+
+  it "searches the current directory without error" do
+    result = Brute::Tools::FSSearch.new.call(pattern: "class FSSearch", path: __dir__)
+    result.should =~ /class FSSearch/
+  end
+
+  it "returns non-zero for no matches" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "empty.txt"), "nothing here\n")
+      result = Brute::Tools::FSSearch.new.call(pattern: "zzz_no_match_zzz", path: dir)
+      result.should.be.kind_of(String)
+    end
+  end
+
+  it "returns a String, not a Hash" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "a.txt"), "hello world\n")
+      Brute::Tools::FSSearch.new.call(pattern: "hello", path: dir).should.be.kind_of(String)
+    end
+  end
+
+  it "caps total results at 100 matches" do
+    Dir.mktmpdir do |dir|
+      150.times { |i| File.write(File.join(dir, "f#{i}.txt"), "match_me\n") }
+      result = Brute::Tools::FSSearch.new.call(pattern: "match_me", path: dir)
+      result.should =~ /showing.*100/i
+    end
+  end
+
+  # --- Per-line truncation ---
+
+  it "truncates long match lines with a preview" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "long.txt"), "x" * 3000 + "\n")
+      result = Brute::Tools::FSSearch.new.call(pattern: "x", path: dir)
+      # Each result line should be capped, not the full 3000 chars
+      result.lines.select { |l| l =~ /long\.txt/ }.each do |line|
+        line.size.should.be < 2200
+      end
+    end
+  end
+
+  # --- Sort by mtime ---
+
+  it "shows most recently modified files first" do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "old.txt"), "findme\n")
+      old_time = Time.now - 1000
+      File.utime(old_time, old_time, File.join(dir, "old.txt"))
+      sleep 0.05
+      File.write(File.join(dir, "new.txt"), "findme\n")
+
+      result = Brute::Tools::FSSearch.new.call(pattern: "findme", path: dir)
+      old_pos = result.index("old.txt")
+      new_pos = result.index("new.txt")
+      new_pos.should.be < old_pos
+    end
+  end
+end

data/lib/brute/tools/fs_undo.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
+require "brute/tools"
 
 module Brute
   module Tools
-    class FSUndo < LLM::Tool
-      name "undo"
+    class FSUndo < RubyLLM::Tool
       description "Undo the last write or patch operation on a file, restoring it to " \
                   "its previous state."
 
-      param :path, String, "Path to the file to undo", required: true
+      param :path, type: 'string', desc: "Path to the file to undo", required: true
+
+      def name; "undo"; end
 
-      def call(path:)
+      def execute(path:)
         target = File.expand_path(path)
         Brute::Queue::FileMutationQueue.serialize(target) do
           snapshot = Brute::Store::SnapshotStore.pop(target)