brute 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2148d5db68a8400e3f3decc496561a7beca3225cc89171c013ba37f3ca48fa6
-  data.tar.gz: bbea8457ac274e5953b55ea54ecc5f29a75cb05cceab3631ab2b29eb47c01346
+  metadata.gz: 4f0f32487b029541fdb462f5f4958a95e4727150911b51f6d8ab457b875187d8
+  data.tar.gz: f162d75e227b4270e4a56dba42fe3cdddd23f9492adeff5cd1f345cbbb811961
 SHA512:
-  metadata.gz: b179135722aca285350004e8ce425a79f4b493d8417090bbd367fcff6fa0213a6cb207b2bd0ca3ede30ff11c7ee972bf7fce71406244f3dc5aa3a0190d939406
-  data.tar.gz: 48eff670f59f22f5dc1389510835ae8f2ca50ca8ec8c0e615bbac10c2c559a50b708859cd47a01fa24c5c406d73000bb7e2f7b49f160832ac157c106ccaed6a5
+  metadata.gz: 9aa172f042960dc5c9ec3250cf27781614077be7db114edc65d4ce72e178dfcab9ed9a9918d6583ed190d36cc54e865d8118bea9ac9814064a12a3f2b7ac8627
+  data.tar.gz: c0cc5addf257b161cc06385417a24833bf9f99a73038040abc67c3caef75ab0a0b9e3d357364b0fa0d194ca3b259555b80f09bf805fc12d17be1e4386d8b061b

data/lib/brute/diff.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+
+module Brute
+  module Diff
+    # Generate a unified diff string from two texts.
+    def self.unified(old_text, new_text, context: 3)
+      old_lines = old_text.lines
+      new_lines = new_text.lines
+      diffs = ::Diff::LCS.diff(old_lines, new_lines)
+      return '' if diffs.empty?
+
+      output = +''
+      file_length_difference = 0
+      diffs.each do |piece|
+        hunk = ::Diff::LCS::Hunk.new(old_lines, new_lines, piece, context, file_length_difference)
+        file_length_difference = hunk.file_length_difference
+        output << hunk.diff(:unified)
+        output << "\n"
+      end
+      output
+    end
+  end
+end

data/lib/brute/middleware/tool_error_tracking.rb

@@ -2,16 +2,19 @@
 
 module Brute
   module Middleware
-    # Tracks per-tool error counts across LLM calls and signals when
-    # the error ceiling is reached.
+    # Tracks per-tool error counts and total tool call count across LLM
+    # calls, and signals when the error ceiling is reached.
     #
     # This middleware doesn't execute tools itself — it inspects the tool
     # results that were sent as input to the LLM call (env[:tool_results])
-    # and counts failures.
+    # and counts failures and totals.
     #
     # When any tool exceeds max_failures, it sets env[:metadata][:tool_error_limit_reached]
     # so the orchestrator can decide to stop.
     #
+    # Also stores env[:metadata][:tool_calls] with the cumulative number of
+    # tool invocations in the current session.
+    #
     class ToolErrorTracking < Base
       DEFAULT_MAX_FAILURES = 3
 
@@ -19,27 +22,30 @@ module Brute
         super(app)
         @max_failures = max_failures
         @errors = Hash.new(0) # tool_name → count
+        @total_tool_calls = 0
       end
 
       def call(env)
-        # PRE: count errors from tool results that are about to be sent
+        # PRE: count errors and totals from tool results that are about to be sent
         if (results = env[:tool_results])
+          @total_tool_calls += results.size
+
           results.each do |name, result|
-            if result.is_a?(Hash) && result[:error]
-              @errors[name] += 1
-            end
+            @errors[name] += 1 if result.is_a?(Hash) && result[:error]
           end
         end
 
+        env[:metadata][:tool_calls] = @total_tool_calls
         env[:metadata][:tool_errors] = @errors.dup
         env[:metadata][:tool_error_limit_reached] = @errors.any? { |_, c| c >= @max_failures }
 
         @app.call(env)
       end
 
-      # Reset error counts (e.g., between user turns).
+      # Reset counts (e.g., between user turns).
       def reset!
         @errors.clear
+        @total_tool_calls = 0
       end
     end
   end

data/lib/brute/middleware/tool_use_guard.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Brute
+  module Middleware
+    # Guards against tool-only LLM responses where the assistant message
+    # is dropped from the context buffer.
+    #
+    # When the LLM responds with only tool_use blocks (no text), llm.rb's
+    # response adapter produces empty choices. Context#talk appends nil,
+    # BufferNilGuard strips it, and the assistant message carrying tool_use
+    # blocks is lost. This causes "unexpected tool_use_id" on the next call
+    # because tool_result references a tool_use that's missing from the buffer.
+    #
+    # This middleware runs post-call and injects a synthetic assistant message
+    # when tool calls exist but no assistant message was recorded.
+    class ToolUseGuard
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        response = @app.call(env)
+
+        ctx = env[:context]
+        functions = ctx.functions
+
+        # If there are pending tool calls, ensure the buffer has an assistant
+        # message with tool_use blocks.
+        if functions && !functions.empty?
+          messages = ctx.messages.to_a
+          last_assistant = messages.reverse.find { |m| m.role.to_s == "assistant" }
+
+          unless last_assistant&.tool_call?
+            # Build a synthetic assistant message with the tool_use data
+            tool_calls = functions.map do |fn|
+              LLM::Object.from(id: fn.id, name: fn.name, arguments: fn.arguments)
+            end
+            original_tool_calls = functions.map do |fn|
+              { "type" => "tool_use", "id" => fn.id, "name" => fn.name, "input" => fn.arguments || {} }
+            end
+
+            synthetic = LLM::Message.new(:assistant, "", {
+              tool_calls: tool_calls,
+              original_tool_calls: original_tool_calls,
+            })
+            ctx.messages.concat([synthetic])
+          end
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/brute/middleware/tracing.rb

@@ -2,31 +2,60 @@
 
 module Brute
   module Middleware
-    # Logs timing and token usage for every LLM call.
+    # Logs timing and token usage for every LLM call, and tracks cumulative
+    # timing data in env[:metadata][:timing].
     #
-    # Wraps the call with wall-clock timing. Logs:
-    #   PRE:  request number, message count
-    #   POST: elapsed time, token usage, finish reason
+    # As the outermost middleware, it sees the full pipeline elapsed time per
+    # call. It also tracks total wall-clock time across all calls in a turn
+    # (including tool execution gaps between LLM calls).
+    #
+    # A new turn is detected when env[:tool_results] is nil (the orchestrator
+    # sets this on the first call of each run()).
+    #
+    # Stores in env[:metadata][:timing]:
+    #   total_elapsed:     wall-clock since the turn began (includes tool gaps)
+    #   total_llm_elapsed: cumulative time spent inside LLM calls only
+    #   llm_call_count:    number of LLM calls so far
+    #   last_call_elapsed: duration of the most recent LLM call
     #
     class Tracing < Base
       def initialize(app, logger:)
         super(app)
         @logger = logger
         @call_count = 0
+        @total_llm_elapsed = 0.0
+        @turn_start = nil
       end
 
       def call(env)
         @call_count += 1
+
+        # Detect new turn: tool_results is nil on the first pipeline call
+        if env[:tool_results].nil?
+          @turn_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @total_llm_elapsed = 0.0
+        end
+
         messages = env[:context].messages.to_a
         @logger.debug("[brute] LLM call ##{@call_count} (#{messages.size} messages in context)")
 
         start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         response = @app.call(env)
-        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        elapsed = now - start
+
+        @total_llm_elapsed += elapsed
 
-        tokens = response.respond_to?(:usage) ? response.usage&.total_tokens : "?"
+        tokens = response.respond_to?(:usage) ? response.usage&.total_tokens : '?'
         @logger.info("[brute] LLM response ##{@call_count}: #{tokens} tokens, #{elapsed.round(2)}s")
 
+        env[:metadata][:timing] = {
+          total_elapsed: now - (@turn_start || start),
+          total_llm_elapsed: @total_llm_elapsed,
+          llm_call_count: @call_count,
+          last_call_elapsed: elapsed
+        }
+
         response
       end
     end

data/lib/brute/orchestrator.rb

@@ -181,6 +181,9 @@ module Brute
         # Handle reasoning params and model-switch normalization (pre-call)
         use Middleware::ReasoningNormalizer, **reasoning unless reasoning.empty?
 
+        # Guard against tool-only responses dropping the assistant message
+        use Middleware::ToolUseGuard
+
         # Innermost: the actual LLM call
         run Middleware::LLMCall.new
       end

data/lib/brute/tools/fs_patch.rb

@@ -3,14 +3,14 @@
 module Brute
   module Tools
     class FSPatch < LLM::Tool
-      name "patch"
-      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."
+      name 'patch'
+      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, 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)'
 
       def call(file_path:, old_string:, new_string:, replace_all: false)
         path = File.expand_path(file_path)
@@ -23,13 +23,15 @@ module Brute
           Brute::SnapshotStore.save(path)
 
           updated = if replace_all
-            original.gsub(old_string, new_string)
-          else
-            original.sub(old_string, new_string)
-          end
+                      original.gsub(old_string, new_string)
+                    else
+                      original.sub(old_string, new_string)
+                    end
 
           File.write(path, updated)
-          {success: true, file_path: path, replacements: replace_all ? original.scan(old_string).size : 1}
+          diff = Brute::Diff.unified(original, updated)
+          count = replace_all ? original.scan(old_string).size : 1
+          { success: true, file_path: path, replacements: count, diff: diff }
         end
       end
     end

data/lib/brute/tools/fs_write.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require "fileutils"
+require 'fileutils'
 
 module Brute
   module Tools
     class FSWrite < LLM::Tool
-      name "write"
+      name 'write'
       description "Write content to a file. Creates parent directories if they don't exist. " \
-                  "Use this for creating new files or completely replacing file contents."
+                  'Use this for creating new files or completely replacing file contents.'
 
-      param :file_path, String, "Path to the file to write", required: true
-      param :content, String, "The full content to write to the file", required: true
+      param :file_path, String, 'Path to the file to write', required: true
+      param :content, String, 'The full content to write to the file', required: true
 
       def call(file_path:, content:)
         path = File.expand_path(file_path)
         Brute::FileMutationQueue.serialize(path) do
+          old_content = File.exist?(path) ? File.read(path) : ''
           Brute::SnapshotStore.save(path)
           FileUtils.mkdir_p(File.dirname(path))
           File.write(path, content)
-          {success: true, file_path: path, bytes: content.bytesize}
+          diff = Brute::Diff.unified(old_content, content)
+          { success: true, file_path: path, bytes: content.bytesize, diff: diff }
         end
       end
     end

data/lib/brute/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Brute
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 end

data/lib/brute.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "llm"
-require "timeout"
-require "logger"
+require 'llm'
+require 'timeout'
+require 'logger'
 
 # Brute — a coding agent built on llm.rb
 #
@@ -11,7 +11,7 @@ require "logger"
 #
 #   Tracing → Retry → Session → Tokens → Compaction → ToolErrors → DoomLoop → Reasoning → [LLM Call]
 #
-require_relative "brute/version"
+require_relative 'brute/version'
 
 module Brute
   module Tools; end
@@ -20,51 +20,52 @@ module Brute
 end
 
 # Infrastructure
-require_relative "brute/snapshot_store"
-require_relative "brute/todo_store"
-require_relative "brute/file_mutation_queue"
-require_relative "brute/doom_loop"
-require_relative "brute/hooks"
-require_relative "brute/compactor"
-require_relative "brute/system_prompt"
-require_relative "brute/session"
-require_relative "brute/pipeline"
-require_relative "brute/agent_stream"
+require_relative 'brute/diff'
+require_relative 'brute/snapshot_store'
+require_relative 'brute/todo_store'
+require_relative 'brute/file_mutation_queue'
+require_relative 'brute/doom_loop'
+require_relative 'brute/hooks'
+require_relative 'brute/compactor'
+require_relative 'brute/system_prompt'
+require_relative 'brute/session'
+require_relative 'brute/pipeline'
+require_relative 'brute/agent_stream'
 
 # Provider patches
-require_relative "brute/patches/anthropic_tool_role"
-require_relative "brute/patches/buffer_nil_guard"
+require_relative 'brute/patches/anthropic_tool_role'
+require_relative 'brute/patches/buffer_nil_guard'
 
 # Middleware (Rack-style)
-require_relative "brute/middleware/base"
-require_relative "brute/middleware/llm_call"
-require_relative "brute/middleware/retry"
-require_relative "brute/middleware/doom_loop_detection"
-require_relative "brute/middleware/token_tracking"
-require_relative "brute/middleware/compaction_check"
-require_relative "brute/middleware/session_persistence"
-require_relative "brute/middleware/tracing"
-require_relative "brute/middleware/tool_error_tracking"
-require_relative "brute/middleware/reasoning_normalizer"
+require_relative 'brute/middleware/base'
+require_relative 'brute/middleware/llm_call'
+require_relative 'brute/middleware/retry'
+require_relative 'brute/middleware/doom_loop_detection'
+require_relative 'brute/middleware/token_tracking'
+require_relative 'brute/middleware/compaction_check'
+require_relative 'brute/middleware/session_persistence'
+require_relative 'brute/middleware/tracing'
+require_relative 'brute/middleware/tool_error_tracking'
+require_relative 'brute/middleware/reasoning_normalizer'
+require_relative "brute/middleware/tool_use_guard"
 
 # Tools
-require_relative "brute/tools/fs_read"
-require_relative "brute/tools/fs_write"
-require_relative "brute/tools/fs_patch"
-require_relative "brute/tools/fs_remove"
-require_relative "brute/tools/fs_search"
-require_relative "brute/tools/fs_undo"
-require_relative "brute/tools/shell"
-require_relative "brute/tools/net_fetch"
-require_relative "brute/tools/todo_write"
-require_relative "brute/tools/todo_read"
-require_relative "brute/tools/delegate"
+require_relative 'brute/tools/fs_read'
+require_relative 'brute/tools/fs_write'
+require_relative 'brute/tools/fs_patch'
+require_relative 'brute/tools/fs_remove'
+require_relative 'brute/tools/fs_search'
+require_relative 'brute/tools/fs_undo'
+require_relative 'brute/tools/shell'
+require_relative 'brute/tools/net_fetch'
+require_relative 'brute/tools/todo_write'
+require_relative 'brute/tools/todo_read'
+require_relative 'brute/tools/delegate'
 
 # Orchestrator (depends on tools, middleware, and infrastructure)
-require_relative "brute/orchestrator"
+require_relative 'brute/orchestrator'
 
 module Brute
-
   # The complete set of tools available to the agent.
   TOOLS = [
     Tools::FSRead,
@@ -77,7 +78,7 @@ module Brute
     Tools::NetFetch,
     Tools::TodoWrite,
     Tools::TodoRead,
-    Tools::Delegate,
+    Tools::Delegate
   ].freeze
 
   # Default provider, resolved from environment.
@@ -102,12 +103,12 @@ module Brute
   end
 
   PROVIDERS = {
-    "anthropic" => ->(key) { LLM.anthropic(key: key).tap { Patches::AnthropicToolRole.apply! } },
-    "openai"    => ->(key) { LLM.openai(key: key) },
-    "google"    => ->(key) { LLM.google(key: key) },
-    "deepseek"  => ->(key) { LLM.deepseek(key: key) },
-    "ollama"    => ->(key) { LLM.ollama(key: key) },
-    "xai"       => ->(key) { LLM.xai(key: key) },
+    'anthropic' => ->(key) { LLM.anthropic(key: key).tap { Patches::AnthropicToolRole.apply! } },
+    'openai' => ->(key) { LLM.openai(key: key) },
+    'google' => ->(key) { LLM.google(key: key) },
+    'deepseek' => ->(key) { LLM.deepseek(key: key) },
+    'ollama' => ->(key) { LLM.ollama(key: key) },
+    'xai' => ->(key) { LLM.xai(key: key) }
   }.freeze
 
   # Resolve the LLM provider from environment variables.
@@ -120,24 +121,24 @@ module Brute
   #
   # Returns nil if no key is found. Error is deferred to Orchestrator#run.
   def self.resolve_provider
-    if ENV["LLM_API_KEY"]
-      key = ENV["LLM_API_KEY"]
-      name = ENV.fetch("LLM_PROVIDER", "anthropic").downcase
-    elsif ENV["ANTHROPIC_API_KEY"]
-      key = ENV["ANTHROPIC_API_KEY"]
-      name = "anthropic"
-    elsif ENV["OPENAI_API_KEY"]
-      key = ENV["OPENAI_API_KEY"]
-      name = "openai"
-    elsif ENV["GOOGLE_API_KEY"]
-      key = ENV["GOOGLE_API_KEY"]
-      name = "google"
+    if ENV['LLM_API_KEY']
+      key = ENV['LLM_API_KEY']
+      name = ENV.fetch('LLM_PROVIDER', 'anthropic').downcase
+    elsif ENV['ANTHROPIC_API_KEY']
+      key = ENV['ANTHROPIC_API_KEY']
+      name = 'anthropic'
+    elsif ENV['OPENAI_API_KEY']
+      key = ENV['OPENAI_API_KEY']
+      name = 'openai'
+    elsif ENV['GOOGLE_API_KEY']
+      key = ENV['GOOGLE_API_KEY']
+      name = 'google'
     else
       return nil
     end
 
     factory = PROVIDERS[name]
-    raise "Unknown LLM provider: #{name}. Available: #{PROVIDERS.keys.join(", ")}" unless factory
+    raise "Unknown LLM provider: #{name}. Available: #{PROVIDERS.keys.join(', ')}" unless factory
 
     factory.call(key)
   end

metadata

@@ -1,56 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Brute Contributors
 bindir: bin
 cert_chain: []
-date: 1980-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: llm.rb
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.11'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.11'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: async
+  name: diff-lcs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: llm.rb
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :development
+        version: '4.11'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '4.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
 description: Production-grade coding agent with tool execution, middleware pipeline,
   context compaction, session persistence, and multi-provider LLM support.
 executables: []
@@ -74,6 +88,7 @@ files:
 - lib/brute.rb
 - lib/brute/agent_stream.rb
 - lib/brute/compactor.rb
+- lib/brute/diff.rb
 - lib/brute/doom_loop.rb
 - lib/brute/file_mutation_queue.rb
 - lib/brute/hooks.rb
@@ -86,6 +101,7 @@ files:
 - lib/brute/middleware/session_persistence.rb
 - lib/brute/middleware/token_tracking.rb
 - lib/brute/middleware/tool_error_tracking.rb
+- lib/brute/middleware/tool_use_guard.rb
 - lib/brute/middleware/tracing.rb
 - lib/brute/orchestrator.rb
 - lib/brute/patches/anthropic_tool_role.rb