brute 5.0.5 → 6.0.0

data/lib/brute/tools/fs_remove.rb

@@ -17,9 +17,13 @@ module Brute
       def execute(path:)
         target = File.expand_path(path)
         Brute::Tools::FS::FileMutationQueue.serialize(target) do
-          raise "Path not found: #{target}" unless File.exist?(target)
+          unless File.exist?(target)
+            raise "Path not found: #{target}"
+          end
 
-          Brute::Tools::FS::SnapshotStore.save(target) if File.file?(target)
+          if File.file?(target)
+            Brute::Tools::FS::SnapshotStore.save(target)
+          end
 
           if File.directory?(target)
             Dir.rmdir(target)

data/lib/brute/tools/fs_search.rb

@@ -36,17 +36,27 @@ module Brute
 
       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)
+        unless File.directory?(dir)
+          raise "Directory not found: #{dir}"
+        end
 
         cmd = ["rg", "--line-number", "--max-columns=2000", "--max-columns-preview", "--sortr=modified"]
-        cmd << "--ignore-case" if ignore_case
-        cmd += ["--glob", glob] if glob
+        if ignore_case
+          cmd << "--ignore-case"
+        end
+        if glob
+          cmd += ["--glob", glob]
+        end
         cmd << pattern
         cmd << dir
 
         stdout, stderr, status = Open3.capture3(*cmd)
 
-        output = stdout.empty? ? stderr : stdout
+        if stdout.empty?
+          output = stderr
+        else
+          output = stdout
+        end
 
         # Global cap at MAX_TOTAL_MATCHES lines
         lines = output.lines

data/lib/brute/tools/fs_undo.rb

@@ -18,10 +18,14 @@ module Brute
         target = File.expand_path(path)
         Brute::Tools::FS::FileMutationQueue.serialize(target) do
           snapshot = Brute::Tools::FS::SnapshotStore.pop(target)
-          raise "No undo history available for: #{target}" unless snapshot
+          unless snapshot
+            raise "No undo history available for: #{target}"
+          end
 
           if snapshot == :did_not_exist
-            File.delete(target) if File.exist?(target)
+            if File.exist?(target)
+              File.delete(target)
+            end
             {success: true, action: "deleted (file did not exist before)"}
           else
             File.write(target, snapshot)

data/lib/brute/tools/fs_write.rb

@@ -19,7 +19,11 @@ module Brute
       def execute(file_path:, content:)
         path = File.expand_path(file_path)
         Brute::Tools::FS::FileMutationQueue.serialize(path) do
-          old_content = File.exist?(path) ? File.read(path) : ''
+          if File.exist?(path)
+            old_content = File.read(path)
+          else
+            old_content = ''
+          end
           Brute::Tools::FS::SnapshotStore.save(path)
           FileUtils.mkdir_p(File.dirname(path))
           File.write(path, content)

data/lib/brute/tools/net_fetch.rb

@@ -21,7 +21,9 @@ module Brute
 
       def execute(url:)
         uri = URI.parse(url)
-        raise "Invalid URL scheme: #{uri.scheme}" unless %w[http https].include?(uri.scheme)
+        unless %w[http https].include?(uri.scheme)
+          raise "Invalid URL scheme: #{uri.scheme}"
+        end
 
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = uri.scheme == "https"
@@ -33,7 +35,9 @@ module Brute
 
         response = http.request(request)
         body = response.body.to_s
-        body = body[0...MAX_BODY] + "\n...(truncated)" if body.size > MAX_BODY
+        if body.size > MAX_BODY
+          body = body[0...MAX_BODY] + "\n...(truncated)"
+        end
 
         {status: response.code.to_i, body: body, content_type: response["content-type"]}
       end

data/lib/brute/tools/question.rb

@@ -14,63 +14,66 @@ module Brute
                   "to allow selecting more than one. If you recommend a specific option, make it " \
                   "the first option and add \"(Recommended)\" at the end of the label."
 
-      params({
-        type: 'object',
-        properties: {
-          questions: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                question: { type: 'string' },
-                header: { type: 'string' },
-                options: {
-                  type: 'array',
-                  items: {
-                    type: 'object',
-                    properties: {
-                      label: { type: 'string' },
-                      description: { type: 'string' },
+      params(
+        {
+          type:       'object',
+          properties: {
+            questions: {
+              type:  'array',
+              items: {
+                type:       'object',
+                properties: {
+                  question: { type: 'string' },
+                  header:   { type: 'string' },
+                  options:  {
+                    type:  'array',
+                    items: {
+                      type:       'object',
+                      properties: {
+                        label:       { type: 'string' },
+                        description: { type: 'string' },
+                      },
+                      required:   %w[label description],
                     },
-                    required: %w[label description],
                   },
+                  multiple: { type: 'boolean' },
                 },
-                multiple: { type: 'boolean' },
+                required:   %w[question header options],
               },
-              required: %w[question header options],
             },
           },
+          required:   %w[questions],
         },
-        required: %w[questions],
-      })
+      )
 
       def name; "question"; end
 
       def execute(questions:)
         handler = Thread.current[:on_question]
-        unless handler
-          return { error: true, message: "Cannot ask questions in non-interactive mode" }
+        if handler
+          queue = Queue.new
+          handler.call(questions, queue)
+          answers = queue.pop
+          format_answers(questions, answers)
+        else
+          { error: true, message: "Cannot ask questions in non-interactive mode" }
         end
-
-        queue = Queue.new
-        handler.call(questions, queue)
-        answers = queue.pop
-
-        format_answers(questions, answers)
       end
 
       private
 
-      def format_answers(questions, answers)
-        pairs = questions.each_with_index.map do |q, i|
-          q = q.transform_keys(&:to_s) if q.is_a?(Hash)
-          header = q["header"]
-          answer = answers[i] || []
-          "\"#{header}\" = #{answer.join(', ')}"
-        end
+        def format_answers(questions, answers)
+          pairs = questions.each_with_index.map do |q, i|
+            if q.is_a?(Hash)
+              q = q.transform_keys(&:to_s)
+          end
+            header = q["header"]
+            answer = answers[i] || []
+            "\"#{header}\" = #{answer.join(', ')}"
+          end
 
-        { response: "User answered: #{pairs.join('; ')}" }
-      end
+          { response: "User answered: #{pairs.join('; ')}" }
+        end
     end
   end
 end

data/lib/brute/tools/shell.rb

@@ -35,13 +35,24 @@ module Brute
       DEFAULT_TIMEOUT = 300 # 5 minutes
 
       def execute(command:, cwd: nil, timeout: nil)
-        dir = cwd ? File.expand_path(cwd) : Dir.pwd
-        raise "Directory not found: #{dir}" unless File.directory?(dir)
+        if cwd
+          dir = File.expand_path(cwd)
+        else
+          dir = Dir.pwd
+        end
+        unless File.directory?(dir)
+          raise "Directory not found: #{dir}"
+        end
 
         timeout_secs = timeout || DEFAULT_TIMEOUT
         stdout, stderr, status = nil
         Timeout.timeout(timeout_secs) do
-          stdout, stderr, status = Open3.capture3("bash", "-c", command, chdir: dir)
+          stdout, stderr, status = Open3.capture3(
+            "bash",
+            "-c",
+            command,
+            chdir: dir,
+          )
         end
 
         out = stdout.to_s
@@ -49,8 +60,12 @@ module Brute
 
         # Combine output, preferring tail-mode truncation so errors/summaries at end are preserved
         combined = out
-        combined += "\nSTDERR:\n#{err}" unless err.empty?
-        combined += "\n[exit code: #{status.exitstatus}]" if status.exitstatus != 0
+        unless err.empty?
+          combined += "\nSTDERR:\n#{err}"
+        end
+        if status.exitstatus != 0
+          combined += "\n[exit code: #{status.exitstatus}]"
+        end
 
         Brute::Truncation.truncate(combined, direction: :tail)
       rescue Timeout::Error

data/lib/brute/tools/skill_load.rb

@@ -40,61 +40,66 @@ module Brute
 
       FILE_LIMIT = 10
 
-      def name; "skill"; end
-
       def initialize(cwd: Dir.pwd)
         super()
         @cwd = cwd
       end
 
+      def name; "skill"; end
+
       def execute(name:)
         skill = Brute::Skill.get(name, cwd: @cwd)
-        return unknown_skill(name) unless skill
-
-        directory = File.dirname(skill.location)
-        files = bundled_files(directory)
-
-        render(skill, directory, files)
+        if skill
+          directory = File.dirname(skill.location)
+          files = bundled_files(directory)
+          render(skill, directory, files)
+        else
+          unknown_skill(name)
+        end
       end
 
       private
 
-      def unknown_skill(name)
-        available = Brute::Skill.all(cwd: @cwd).map(&:name)
-        listing = available.empty? ? "(none)" : available.join(", ")
-        "Error: unknown skill #{name.inspect}. Available skills: #{listing}"
-      end
-
-      def bundled_files(directory)
-        Dir.glob(File.join(directory, "**", "*"), File::FNM_DOTMATCH)
-           .select { |p| File.file?(p) }
-           .reject { |p| File.basename(p) == Brute::Skill::FILENAME }
-           .map { |p| Pathname.new(p).relative_path_from(Pathname.new(directory)).to_s }
-           .sort
-           .first(FILE_LIMIT)
-      end
+        def unknown_skill(name)
+          available = Brute::Skill.all(cwd: @cwd).map(&:name)
+          if available.empty?
+            listing = "(none)"
+        else
+          listing = available.join(", ")
+        end
+          "Error: unknown skill #{name.inspect}. Available skills: #{listing}"
+        end
 
-      def render(skill, directory, files)
-        lines = [
-          "<skill name=\"#{skill.name}\">",
-          "# Skill: #{skill.name}",
-          "",
-          skill.content,
-          "",
-          "Base directory for this skill: #{directory}",
-          "Relative paths in this skill (e.g. scripts/, references/, assets/) are relative to " \
-            "this base directory. Use your existing tools (read, shell) to access them.",
-        ]
-
-        unless files.empty?
-          lines << ""
-          lines << "Bundled files (sampled, up to #{FILE_LIMIT}):"
-          files.each { |f| lines << "  #{f}" }
+        def bundled_files(directory)
+          Dir.glob(File.join(directory, "**", "*"), File::FNM_DOTMATCH)
+             .select { |p| File.file?(p) }
+             .reject { |p| File.basename(p) == Brute::Skill::FILENAME }
+             .map { |p| Pathname.new(p).relative_path_from(Pathname.new(directory)).to_s }
+             .sort
+             .first(FILE_LIMIT)
         end
 
-        lines << "</skill>"
-        lines.join("\n")
-      end
+        def render(skill, directory, files)
+          lines = [
+            "<skill name=\"#{skill.name}\">",
+            "# Skill: #{skill.name}",
+            "",
+            skill.content,
+            "",
+            "Base directory for this skill: #{directory}",
+            "Relative paths in this skill (e.g. scripts/, references/, assets/) are relative to " \
+              "this base directory. Use your existing tools (read, shell) to access them.",
+          ]
+
+          unless files.empty?
+            lines << ""
+            lines << "Bundled files (sampled, up to #{FILE_LIMIT}):"
+            files.each { |f| lines << "  #{f}" }
+          end
+
+          lines << "</skill>"
+          lines.join("\n")
+        end
     end
   end
 end

data/lib/brute/tools/sub_agent.rb

@@ -21,7 +21,7 @@ module Brute
     #     use Brute::Middleware::SystemPrompt
     #     use Brute::Middleware::Loop::ToolResult
     #     use Brute::Middleware::MaxIterations, max_iterations: 10
-    #     use Brute::Middleware::ToolPipeline, tools: [Brute::Tools::FSRead, Brute::Tools::FSSearch]
+    #     use Brute::Middleware::DefaultToolPipeline, tools: [Brute::Tools::FSRead, Brute::Tools::FSSearch]
     #     run ->(env) do
     #       # The LLM call, written with your library of choice. Convert
     #       # env[:messages] to its format, call it, and append the response
@@ -32,7 +32,7 @@ module Brute
     #
     #   # The SubAgent IS a tool — hand it to a parent agent's ToolPipeline:
     #   main_agent = Brute.agent do
-    #     use Brute::Middleware::ToolPipeline, tools: [Brute::Tools::FSRead, researcher]
+    #     use Brute::Middleware::DefaultToolPipeline, tools: [Brute::Tools::FSRead, researcher]
     #     run ->(env) { ... }
     #   end
     #   main_agent.start("delegate some research")

data/lib/brute/tools/todo_write.rb

@@ -10,30 +10,34 @@ module Brute
       description "Create or update the todo list. Send the complete list each time — " \
                   "this replaces the existing list entirely."
 
-      params({
-        type: 'object',
-        properties: {
-          todos: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                id: { type: 'string' },
-                content: { type: 'string' },
-                status: { type: 'string', enum: %w[pending in_progress completed cancelled] },
+      params(
+        {
+          type:       'object',
+          properties: {
+            todos: {
+              type:  'array',
+              items: {
+                type:       'object',
+                properties: {
+                  id:      { type: 'string' },
+                  content: { type: 'string' },
+                  status:  { type: 'string', enum: %w[pending in_progress completed cancelled] },
+                },
+                required:   %w[id content status],
               },
-              required: %w[id content status],
             },
           },
+          required:   %w[todos],
         },
-        required: %w[todos],
-      })
+      )
 
       def name; "todo_write"; end
 
       def execute(todos:)
         items = todos.map do |t|
-          t = t.transform_keys(&:to_sym) if t.is_a?(Hash)
+          if t.is_a?(Hash)
+            t = t.transform_keys(&:to_sym)
+          end
           {id: t[:id], content: t[:content], status: t[:status]}
         end
         Brute::Tools::TodoList::Store.replace(items)

data/lib/brute/truncation.rb

@@ -40,7 +40,13 @@ module Brute
     MAX_LINE_LENGTH = 2000
     TRUNCATION_MARKER = "[Output truncated:"
 
-    TRUNCATION_DIR = File.join(Dir.home, ".local", "share", "brute", "tool-output")
+    TRUNCATION_DIR = File.join(
+      Dir.home,
+      ".local",
+      "share",
+      "brute",
+      "tool-output",
+    )
 
     # Truncate text to fit within line and byte limits.
     #
@@ -55,38 +61,48 @@ module Brute
     # @returns [String] the (possibly truncated) text
     #
     def self.truncate(text, max_lines: MAX_LINES, max_bytes: MAX_BYTES, direction: :head, truncation_dir: nil)
-      return text if text.nil? || text.empty?
-
-      # Per-line truncation first — cap individual lines
-      lines = text.lines.map { |line| truncate_line(line) }
-      text = lines.join
-
-      return text if lines.size <= max_lines && text.bytesize <= max_bytes
-
-      # Determine how many lines we can keep within both caps
-      kept = direction == :tail ? lines.last(max_lines) : lines.first(max_lines)
-
-      # Enforce byte cap
-      result_lines = []
-      bytes = 0
-      kept.each do |line|
-        break if bytes + line.bytesize > max_bytes
-        result_lines << line
-        bytes += line.bytesize
-      end
-
-      result = result_lines.join
-      total = lines.size
-      shown = result_lines.size
-
-      # Overflow to disk — save the full output so it can be inspected later
-      saved_path = save_to_disk(text, truncation_dir)
-
-      hint = "\n#{TRUNCATION_MARKER} showing #{shown} of #{total} lines]"
-      if saved_path
-        hint += "\nFull output saved to: #{saved_path}. Use Read with offset/limit to view specific sections."
+      if text.nil? || text.empty?
+        text
+      else
+        # Per-line truncation first — cap individual lines
+        lines = text.lines.map { |line| truncate_line(line) }
+        text = lines.join
+
+        if lines.size <= max_lines && text.bytesize <= max_bytes
+          text
+        else
+          # Determine how many lines we can keep within both caps
+          if direction == :tail
+            kept = lines.last(max_lines)
+          else
+            kept = lines.first(max_lines)
+          end
+
+          # Enforce byte cap
+          result_lines = []
+          bytes = 0
+          kept.each do |line|
+            if bytes + line.bytesize > max_bytes
+              break
+            end
+            result_lines << line
+            bytes += line.bytesize
+          end
+
+          result = result_lines.join
+          total = lines.size
+          shown = result_lines.size
+
+          # Overflow to disk — save the full output so it can be inspected later
+          saved_path = save_to_disk(text, truncation_dir)
+
+          hint = "\n#{TRUNCATION_MARKER} showing #{shown} of #{total} lines]"
+          if saved_path
+            hint += "\nFull output saved to: #{saved_path}. Use Read with offset/limit to view specific sections."
+          end
+          result + hint
+        end
       end
-      result + hint
     end
 
     # Check whether text already contains a truncation marker.
@@ -96,27 +112,36 @@ module Brute
 
     # Truncate a single line if it exceeds MAX_LINE_LENGTH.
     def self.truncate_line(line, max: MAX_LINE_LENGTH)
-      return line if line.length <= max
-      line[0, max] + "... (line truncated to #{max} chars)\n"
+      if line.length <= max
+        line
+      else
+        line[0, max] + "... (line truncated to #{max} chars)\n"
+      end
     end
 
     # Purge files older than retention_days from the given directory.
     def self.cleanup!(dir, retention_days: 7)
-      return unless File.directory?(dir)
-      cutoff = Time.now - (retention_days * 86400)
-      Dir.glob(File.join(dir, "*")).each do |path|
-        File.delete(path) if File.file?(path) && File.mtime(path) < cutoff
+      if File.directory?(dir)
+        cutoff = Time.now - (retention_days * 86400)
+        Dir.glob(File.join(dir, "*")).each do |path|
+          if File.file?(path) && File.mtime(path) < cutoff
+            File.delete(path)
+          end
+        end
+      else
+        nil
       end
     end
 
     # Save text to a file in truncation_dir. Returns the file path, or nil.
     def self.save_to_disk(text, truncation_dir)
       dir = truncation_dir || TRUNCATION_DIR
-      return nil unless dir
-      FileUtils.mkdir_p(dir)
-      path = File.join(dir, "tool_#{SecureRandom.hex(8)}.txt")
-      File.write(path, text)
-      path
+      if dir
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, "tool_#{SecureRandom.hex(8)}.txt")
+        File.write(path, text)
+        path
+      end
     rescue => _e
       nil
     end

data/lib/brute/turn/agent_pipeline.rb

@@ -38,8 +38,10 @@ module Brute
       # the newest message, only when it is a user message, before the rest
       # of the stack.
       def map(matcher, &block)
-        (@commands ||= []) << [check(matcher), block]
-        self
+        tap do
+          @commands ||= []
+          @commands << [check(matcher), block]
+        end
       end
 
       # Every chain starts with the commands, registry or no registry: the
@@ -50,21 +52,25 @@ module Brute
       end
       alias_method :build, :to_app
 
-      def start(input = nil, events: NullSink.new)
-        env = {
+      def start(input = nil)
+        {
           messages:          coerce_messages(input),
-          events:            events,
           metadata:          {},
           current_iteration: 1,
           commands:          @commands || [],
-        }
-        hooks.emit(TURN_START_EVENT, env)
-        begin
-          hooks.emit(TURN_DURATION_EVENT, env) { build.call(env) }
-        ensure
-          hooks.emit(TURN_END_EVENT, env)
+        }.tap do |turn|
+          Brute::Hooks::Trace.new(turn, hooks: hooks).emit_trace do |env|
+            env.emit(TURN_START_EVENT)
+            begin
+              env.emit(TURN_DURATION_EVENT) { build.call(env) }
+            rescue => error
+              env.emit(TURN_FAILURE_EVENT, error)
+              raise
+            ensure
+              env.emit(TURN_END_EVENT)
+            end
+          end
         end
-        env
       end
 
       private
@@ -86,7 +92,11 @@ module Brute
             matcher
           else
             name = matcher.to_s
-            name = name.start_with?("/") ? name : "/#{name}"
+            if name.start_with?("/")
+              name = name
+            else
+              name = "/#{name}"
+            end
             /^#{::Regexp.escape(name)}.*/
           end
         end