brute 5.1.0 → 6.0.1

data/lib/brute/tools/fs_read.rb

@@ -47,101 +47,128 @@ module Brute
         path = File.expand_path(file_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
+        if File.directory?(path)
+          list_directory(path)
+        else
+          # File-not-found suggestions
+          unless File.exist?(path)
+            suggestions = find_similar(path)
+            msg = "File not found: #{path}"
+            if suggestions.any?
+              msg += ". Did you mean: #{suggestions.join(', ')}?"
+            end
+            raise msg
+          end
 
-        # 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
+          unless File.file?(path)
+            raise "Not a file: #{path}"
+          end
 
-        selected = lines[first..last] || []
+          # Binary file detection
+          ext = File.extname(path).downcase
+          if BINARY_EXTENSIONS.include?(ext)
+            raise "Cannot read binary file: #{path}"
+          end
+          sample = File.binread(path, 4096) || ""
+          if sample.include?("\x00")
+            raise "Cannot read binary file: #{path}"
+          end
 
-        # 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
+          lines = File.readlines(path)
+          total = lines.size
+          if start_line
+            first = [start_line - 1, 0].max
+          else
+            first = 0
+          end
 
-        actual_last = first + numbered.size - 1
-        content = numbered.join
-        truncated = (actual_last < total - 1) && end_line.nil?
+          # Apply default line cap when no explicit range given
+          if end_line
+            default_last = [end_line - 1, total - 1].min
+          else
+            default_last = [first + DEFAULT_LINE_CAP - 1, total - 1].min
+          end
+          last = default_last
+          selected = lines[first..last] || []
+
+          # 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}"
+            if bytes + numbered_line.bytesize > MAX_BYTES
+              break
+            end
+            numbered << numbered_line
+            bytes += numbered_line.bytesize
+          end
 
-        if truncated
-          content + "\n(Showing lines #{first + 1}-#{actual_last + 1} of #{total}. Use start_line=#{actual_last + 2} to continue.)"
-        else
-          content
+          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
       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 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)
+            if File.directory?(full)
+              type = "dir"
+          else
+            type = "file"
+          end
+            "#{entry} (#{type})"
+          end.join("\n")
 
-      def find_similar(path)
-        dir = File.dirname(path)
-        target = File.basename(path)
-        return [] unless File.directory?(dir)
+          if total > DEFAULT_LINE_CAP
+            result += "\n(Showing #{DEFAULT_LINE_CAP} of #{total} entries)"
+          end
+          result
+        end
 
-        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 find_similar(path)
+          dir = File.dirname(path)
+          target = File.basename(path)
+          if 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)
+          else
+            []
+          end
+        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
+        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|
+              if a[i - 1] == b[j - 1]
+                cost = 0
+              else
+                cost = 1
+              end
+              temp = d[i]
+              d[i] = [d[i] + 1, d[i - 1] + 1, prev + cost].min
+              prev = temp
+            end
           end
+          d[m]
         end
-        d[m]
-      end
     end
   end
 end

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

@@ -49,52 +49,57 @@ module Brute
 
       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/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)