brute 2.0.6 → 3.0.0

data/lib/brute/turn/pipeline.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Turn
+    class Pipeline < ::Rack::Builder
+      module Chainable
+        # Enables the following syntax:
+        #
+        #   Brute.agent
+        #     .use(UltraSecurity)
+        #     .use(MaxProfit)
+        #     .use(DontTellMom)
+        #     .run -> (env) {
+        #       RubyLLM.chat.ask("How to make money?")
+        #     }
+        #
+        def use(...) = tap { super }
+        def run(...) = tap { super }
+      end
+
+      include Chainable
+
+      # Rack's `new_from_string` evaluates the script then returns `to_app` —
+      # the built callable. An agent, though, is the *builder*: you `.start` it,
+      # and it may be re-`use`d or served through the Rack adapter. So evaluate
+      # the script against a fresh builder and hand back the builder itself.
+      # This also backs `parse_file` (→ `load_file` → here), so
+      # `AgentPipeline.parse_file("agent.ru").start(prompt)` works as documented.
+      def self.new_from_string(builder_script, path = "(rackup)", **options)
+        builder = new(**options)
+        eval(builder_script, ::Rack::BUILDER_TOPLEVEL_BINDING.call(builder), path) # rubocop:disable Security/Eval
+        builder
+      end
+
+      # Brute's name for Rack's `to_app`: nest the middleware around the
+      # terminal app and return the runnable callable. Raises (via `to_app`)
+      # when `run` was never called.
+      alias_method :build, :to_app
+
+      # Default null sink for env[:events] — swallows anything pushed to it.
+      class NullSink
+        def <<(_event); self; end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "brute/turn/pipeline" do
+  it "builds and calls a chain" do
+    seen = []
+    inc = Class.new do
+      def initialize(app, label:); @app = app; @label = label; end
+      def call(env); env[:trace] << @label; @app.call(env); env[:trace] << "#{@label}-after"; end
+    end
+
+    pipeline = Brute::Turn::Pipeline.new do
+      use inc, label: "outer"
+      use inc, label: "inner"
+      run ->(env) { env[:trace] << "core" }
+    end
+
+    env = { trace: [] }
+    pipeline.call(env)
+    env[:trace].should == ["outer", "inner", "core", "inner-after", "outer-after"]
+  end
+
+  it "raises when run was never called" do
+    lambda { Brute::Turn::Pipeline.new.call({}) }.should.raise(RuntimeError)
+  end
+
+  it "accepts a callable as the terminal app" do
+    pipeline = Brute::Turn::Pipeline.new do
+      run ->(env) { env[:result] = 42 }
+    end
+    env = {}
+    pipeline.call(env)
+    env[:result].should == 42
+  end
+
+  it "run accepts a block terminal and stays chainable" do
+    pipeline = Brute::Turn::Pipeline.new.use(Class.new do
+      def initialize(app); @app = app; end
+      def call(env); env[:trace] << "mw"; @app.call(env); end
+    end).run { |env| env[:trace] << "core" }
+
+    env = { trace: [] }
+    pipeline.call(env)
+    env[:trace].should == ["mw", "core"]
+  end
+end

data/lib/brute/turn/tool_pipeline.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require "brute/turn/pipeline"
+
+module Brute
+  module Turn
+    # A ToolPipeline runs a tool call through a middleware stack. Like
+    # AgentPipeline it *composes* a Pipeline rather than inheriting: the
+    # definition block is instance_eval'd into the internal Pipeline, so `use`
+    # / `run` inside it are the builder's methods. The tool's terminal app does
+    # the work; middleware wraps it with concerns like file mutation queueing,
+    # validation, logging.
+    #
+    # Coexists with Brute::Tools::* (which inherit from RubyLLM::Tool). Use a
+    # ToolPipeline when you want middleware; use RubyLLM::Tool subclasses for
+    # simple cases.
+    #
+    #   read = Brute::Turn::ToolPipeline.new(
+    #     name:        "read",
+    #     description: "Read a file's contents",
+    #     params:      { file_path: { type: "string", required: true } },
+    #   ) do
+    #     use Brute::Middleware::Tool::ValidateParams
+    #     run ->(env) {
+    #       env[:result] = File.read(File.expand_path(env[:arguments][:file_path]))
+    #     }
+    #   end
+    #
+    #   read.call(file_path: "lib/brute.rb")
+    #
+    class ToolPipeline
+      attr_reader :name, :description, :params
+
+      def initialize(name:, description:, params: {}, &block)
+        @name        = name.to_s
+        @description = description
+        @params      = params
+        @pipeline    = Pipeline.new
+        @pipeline.instance_eval(&block) if block
+      end
+
+      def call(events: Pipeline::NullSink.new, **arguments)
+        env = {
+          name:      @name,
+          arguments: arguments,
+          result:    nil,
+          events:    events,
+          metadata:  {},
+        }
+        @pipeline.call(env)
+        env[:result]
+      end
+
+      # Adapter so the LLM can call this tool through ruby_llm.
+      def to_ruby_llm
+        tool = self
+        Class.new(RubyLLM::Tool) do
+          description tool.description
+          tool.params.each { |k, opts| param k, **opts }
+          define_method(:name) { tool.name }
+          define_method(:execute) { |**args| tool.call(**args) }
+        end.new
+      end
+    end
+  end
+end
+
+__END__
+
+describe "brute/turn/tool_pipeline" do
+  it "exposes name, description, params" do
+    t = Brute::Turn::ToolPipeline.new(name: "echo", description: "echo input") do
+      run ->(env) { env[:result] = env[:arguments][:msg] }
+    end
+
+    t.name.should == "echo"
+    t.description.should == "echo input"
+    t.call(msg: "hi").should == "hi"
+  end
+
+  it "passes arguments through env to the terminal app" do
+    captured = nil
+    t = Brute::Turn::ToolPipeline.new(name: "x", description: "x") do
+      run ->(env) { captured = env[:arguments]; env[:result] = nil }
+    end
+
+    t.call(a: 1, b: 2)
+    captured.should == { a: 1, b: 2 }
+  end
+
+  it "runs middleware around the terminal app (instance_eval'd block)" do
+    wrap = Class.new do
+      def initialize(app, tag:); @app = app; @tag = tag; end
+      def call(env); (env[:metadata][:log] ||= []) << "in-#{@tag}"; @app.call(env); env[:metadata][:log] << "out-#{@tag}"; end
+    end
+
+    t = Brute::Turn::ToolPipeline.new(name: "x", description: "x") do
+      use wrap, tag: "a"
+      run ->(env) { env[:metadata][:log] << "core"; env[:result] = :ok }
+    end
+
+    t.call(input: 1).should == :ok
+  end
+end

data/lib/brute/utils/diff.rb

@@ -27,7 +27,9 @@ module Brute
   end
 end
 
-test do
+__END__
+
+describe "brute/utils/diff" do
   it "generates a unified diff for changed content" do
     Brute::Diff.unified("line1\nold\nline3\n", "line1\nnew\nline3\n").should =~ /\-old/
   end

data/lib/brute/version.rb

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

data/lib/brute.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
-require 'ruby_llm'
+require "bundler/setup"
+
+require "ruby_llm"
 require "rack"
 require 'timeout'
 require 'logger'
-require 'scampi/kernel_ext'
 require 'colorize_extended'
 require 'active_support/all'
 
-# Brute — a coding agent built on ruby_llm
-#
-# Cross-cutting concerns are implemented as Rack-style middleware in a
-# Pipeline that wraps every LLM call:
-#
-#   Tracing → Retry → Session → Tokens → Compaction → ToolErrors → DoomLoop → Reasoning → [LLM Call]
-#
-
-require 'brute/version'
+require_relative 'brute/version'
 
 module Brute
   LOGO = <<-LOGO
@@ -29,76 +22,58 @@ module Brute
  `Y8bod8P' d888b     `V88V"V8P'   "888" `Y8bod8P' 
   LOGO
 
-  def self.config
-    @config ||= begin
-      RubyLLM.configure do |config|
-        # Anthropic
-        config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
-        config.anthropic_api_base = ENV['ANTHROPIC_API_BASE'] # Available in v1.13.0+ (optional custom Anthropic endpoint)
-      
-        # Azure
-        config.azure_api_base = ENV['AZURE_API_BASE'] # Microsoft Foundry project endpoint
-        config.azure_api_key = ENV['AZURE_API_KEY'] # use this or
-        config.azure_ai_auth_token = ENV['AZURE_AI_AUTH_TOKEN'] # this
-      
-        # Bedrock
-        config.bedrock_api_key = ENV['AWS_ACCESS_KEY_ID']
-        config.bedrock_secret_key = ENV['AWS_SECRET_ACCESS_KEY']
-        config.bedrock_region = ENV['AWS_REGION'] # Required for Bedrock
-        config.bedrock_session_token = ENV['AWS_SESSION_TOKEN'] # For temporary credentials
-      
-        # DeepSeek
-        config.deepseek_api_key = ENV['DEEPSEEK_API_KEY']
-        config.deepseek_api_base = ENV['DEEPSEEK_API_BASE'] # Available in v1.13.0+ (optional custom DeepSeek endpoint)
-      
-        # Gemini
-        config.gemini_api_key = ENV['GEMINI_API_KEY']
-        config.gemini_api_base = ENV['GEMINI_API_BASE'] # Available in v1.9.0+ (optional API version override)
-      
-        # GPUStack
-        config.gpustack_api_base = ENV['GPUSTACK_API_BASE']
-        config.gpustack_api_key = ENV['GPUSTACK_API_KEY']
-      
-        # Mistral
-        config.mistral_api_key = ENV['MISTRAL_API_KEY']
-      
-        # Ollama
-        config.ollama_api_base = 'http://localhost:11434/v1'
-        config.ollama_api_key = ENV['OLLAMA_API_KEY'] # Available in v1.13.0+ (optional for authenticated/remote Ollama endpoints)
-      
-        # OpenAI
-        config.openai_api_key = ENV['OPENAI_API_KEY']
-        config.openai_api_base = ENV['OPENAI_API_BASE'] # Optional custom OpenAI-compatible endpoint
-      
-        # OpenRouter
-        config.openrouter_api_key = ENV['OPENROUTER_API_KEY']
-        config.openrouter_api_base = ENV['OPENROUTER_API_BASE'] # Available in v1.13.0+ (optional custom OpenRouter endpoint)
-      
-        # Perplexity
-        config.perplexity_api_key = ENV['PERPLEXITY_API_KEY']
-      
-        # Vertex AI
-        config.vertexai_project_id = ENV['GOOGLE_CLOUD_PROJECT'] # Available in v1.7.0+
-        config.vertexai_location = ENV['GOOGLE_CLOUD_LOCATION']
-        config.vertexai_service_account_key = ENV['VERTEXAI_SERVICE_ACCOUNT_KEY'] # Optional: service account JSON key
-      
-        # xAI
-        config.xai_api_key = ENV['XAI_API_KEY'] # Available in v1.11.0+
-      end
-      RubyLLM.config
-    end
-  end
+  # NOTE: Brute owns no LLM configuration. Calling an LLM is just
+  # `RubyLLM.chat.ask "..."`, and all provider/model/credential config lives
+  # in the pipeline's terminal `run` proc — typically via `RubyLLM.context`:
+  #
+  #   run ->(env) do
+  #     context = RubyLLM.context { |c| c.ollama_api_base = ENV["OLLAMA_API_BASE"] }
+  #     ...
+  #   end
+  #
+  # See examples/agents/01_basic_agent.rb.
 
   def self.provider
     @provider ||= :anthropic
   end
+
+  # Start building an agent turn. Returns an AgentPipeline — a rack-style
+  # builder that is also the runnable Agent: chain `.use` for middleware and
+  # `.run` for the terminal LLM-call proc (both return the AgentPipeline), then
+  # invoke it with `#start`. It takes no config — LLM config lives in the `run`
+  # proc, tools go to the ToolPipeline middleware, the log to SessionLog.
+  #
+  #   agent = Brute.agent
+  #     .use(Brute::Middleware::SystemPrompt)
+  #     .use(Brute::Middleware::ToolPipeline, tools: Brute::Tools::ALL)
+  #     .run ->(env) { ... }      # the LLM-call proc (provider/model/creds here)
+  #
+  #   agent.start("what changed?")
+  #
+  # A block form is equivalent (evaluated in the AgentPipeline's context):
+  #
+  #   Brute.agent do
+  #     use Brute::Middleware::SystemPrompt
+  #     run ->(env) { ... }
+  #   end
+  def self.agent(&block)
+    Brute::Turn::AgentPipeline.new(&block)
+  end
+
+  # Adapt any Brute tools (hashes, Brute::Turn::ToolPipeline, SubAgent, RubyLLM::Tool …)
+  # into a { name_sym => RubyLLM::Tool } hash — the shape an inline `run`
+  # proc hands to RubyLLM.chat.with_tools or a provider #complete call.
+  def self.rubyllm_tools(tools)
+    Brute::Tools::Adapter.wrap_all(tools || []).transform_values(&:to_ruby_llm)
+  end
   
   def self.provider=(p)
     @provider = p.to_sym
   end
 end
 
-Dir.glob("#{__dir__}/brute/**/*.rb").sort.each do |path|
+Dir.glob("#{__dir__}/{brute,ruby_llm}/**/*.rb").sort.each do |path|
   require path
 end
 
+# gangsta g-dogg bruh...

data/lib/{brute → brute_cli}/providers/shell.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "brute"
+
 require "shellwords"
 
-module Brute
+module BruteCLI
   module Providers
     # A pseudo-LLM provider that executes user input as code via the
     # existing Brute::Tools::Shell tool.

data/lib/{brute → brute_cli}/providers/shell_response.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
 
 require "securerandom"
 
-module Brute
+module BruteCLI
   module Providers
     # Synthetic completion response returned by Brute::Providers::Shell.
     #

data/lib/ruby_llm/message_transport.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module RubyLLM
+  # Transports the result of an LLM call into Brute's message format.
+  #
+  # Calling an LLM is trivial — `RubyLLM.chat.ask "..."` — so Brute has no
+  # "completion middleware". The terminal `run` of an agent pipeline is an
+  # inline proc that makes the LLM call itself. The only wrinkle: RubyLLM hands
+  # back its own objects (a Message, an array, a whole Chat transcript), while
+  # the rest of the stack — the turn manager, event handlers, tool loop and
+  # SessionLog persistence — works off `env[:messages]` (a plain message log;
+  # see Brute.log).
+  #
+  # This makes NO LLM call and does NO appending. It just wraps what the proc
+  # got back and yields each message in Brute's format; the proc appends:
+  #
+  #   response = provider.complete(env[:messages], ...)          # one Message
+  #   RubyLLM::MessageTransport.new(response).wrap_each do |message|
+  #     env[:messages] << message
+  #   end
+  #
+  #   before = chat.messages.length                              # a Chat loop
+  #   chat.complete
+  #   RubyLLM::MessageTransport.new(chat.messages[before..]).wrap_each do |message|
+  #     env[:messages] << message
+  #   end
+  class MessageTransport
+    # Convenience: RubyLLM::MessageTransport.wrap_each(result) { |m| ... }
+    def self.wrap_each(result, &block)
+      new(result).wrap_each(&block)
+    end
+
+    def initialize(result)
+      @result = result
+    end
+
+    # Yield each result message in Brute's format. Without a block, returns an
+    # Enumerator. The caller decides what to do with each (typically append to
+    # env[:messages]).
+    def wrap_each
+      return enum_for(:wrap_each) unless block_given?
+
+      messages.each { |message| yield wrap(message) }
+    end
+
+    # The result normalized to a flat list of messages. A single Message, an
+    # array, or anything transcript-shaped (a Chat responds to #messages).
+    def messages
+      case @result
+      when ::RubyLLM::Message then [@result]
+      when Array              then @result.compact
+      else @result.respond_to?(:messages) ? @result.messages : Array(@result)
+      end
+    end
+
+    private
+
+      # The Brute-format view of a single message. RubyLLM::Message already IS
+      # Brute's message format, so this is the identity seam — the place to
+      # normalize if the two formats ever diverge.
+      def wrap(message)
+        message
+      end
+  end
+end
+
+__END__
+
+describe "ruby_llm/message_transport" do
+  require "brute/messages"
+
+  it "wraps a single message" do
+    message = RubyLLM::Message.new(role: :assistant, content: "hi")
+    RubyLLM::MessageTransport.new(message).wrap_each.to_a.should == [message]
+  end
+
+  it "wraps an array of messages" do
+    a = RubyLLM::Message.new(role: :assistant, content: "one")
+    b = RubyLLM::Message.new(role: :tool, content: "two", tool_call_id: "tc1")
+    RubyLLM::MessageTransport.new([a, b]).wrap_each.to_a.should == [a, b]
+  end
+
+  it "wraps a transcript-shaped object (a Chat)" do
+    fake_chat = Class.new do
+      attr_reader :messages
+      def initialize(messages); @messages = messages; end
+    end
+    msgs = [RubyLLM::Message.new(role: :user, content: "hi"),
+            RubyLLM::Message.new(role: :assistant, content: "hello")]
+
+    RubyLLM::MessageTransport.new(fake_chat.new(msgs)).wrap_each.to_a.map(&:role).should == [:user, :assistant]
+  end
+
+  it "yields each message to the block for the caller to append" do
+    session = Brute.log
+    session.user("hello")
+    response = RubyLLM::Message.new(role: :assistant, content: "hi there")
+
+    RubyLLM::MessageTransport.new(response).wrap_each { |message| session << message }
+
+    session.last.role.should == :assistant
+    session.last.content.should == "hi there"
+  end
+
+  it "exposes a class-level wrap_each convenience" do
+    session = Brute.log
+    a = RubyLLM::Message.new(role: :assistant, content: "a")
+    b = RubyLLM::Message.new(role: :assistant, content: "b")
+
+    RubyLLM::MessageTransport.wrap_each([a, b]) { |message| session << message }
+
+    session.map(&:content).should == ["a", "b"]
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 3.0.0
 platform: ruby
 authors:
 - Brute Contributors
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -51,20 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: scampi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -163,6 +149,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: scampi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Production-grade coding agent with tool execution, middleware pipeline,
   context compaction, session persistence, and multi-provider LLM support.
 executables: []
@@ -170,26 +170,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/brute.rb
-- lib/brute/agent.rb
 - lib/brute/events/handler.rb
 - lib/brute/events/prefixed_terminal_output.rb
 - lib/brute/events/terminal_output_handler.rb
+- lib/brute/messages.rb
 - lib/brute/middleware/001_otel_span.rb
-- lib/brute/middleware/003_tool_result_loop.rb
+- lib/brute/middleware/002_session_log.rb
 - lib/brute/middleware/004_summarize.rb
 - lib/brute/middleware/005_tracing.rb
+- lib/brute/middleware/006_loop.rb
 - lib/brute/middleware/010_max_iterations.rb
 - lib/brute/middleware/015_otel_token_usage.rb
 - lib/brute/middleware/020_system_prompt.rb
 - lib/brute/middleware/040_compaction_check.rb
 - lib/brute/middleware/060_questions.rb
-- lib/brute/middleware/070_tool_call.rb
+- lib/brute/middleware/070_tool_pipeline.rb
 - lib/brute/middleware/073_otel_tool_call.rb
 - lib/brute/middleware/075_otel_tool_results.rb
-- lib/brute/middleware/100_llm_call.rb
 - lib/brute/middleware/event_handler.rb
 - lib/brute/middleware/user_queue.rb
-- lib/brute/pipeline.rb
 - lib/brute/prompts.rb
 - lib/brute/prompts/autonomy.rb
 - lib/brute/prompts/base.rb
@@ -232,17 +231,13 @@ files:
 - lib/brute/prompts/text/tool_usage/google.txt
 - lib/brute/prompts/tone_and_style.rb
 - lib/brute/prompts/tool_usage.rb
-- lib/brute/providers/shell.rb
-- lib/brute/providers/shell_response.rb
-- lib/brute/queue/file_mutation_queue.rb
-- lib/brute/session.rb
+- lib/brute/rack/adapter.rb
 - lib/brute/skill.rb
-- lib/brute/store/snapshot_store.rb
-- lib/brute/store/todo_store.rb
-- lib/brute/sub_agent.rb
 - lib/brute/system_prompt.rb
-- lib/brute/tool.rb
 - lib/brute/tools.rb
+- lib/brute/tools/adapter.rb
+- lib/brute/tools/fs/file_mutation_queue.rb
+- lib/brute/tools/fs/snapshot_store.rb
 - lib/brute/tools/fs_patch.rb
 - lib/brute/tools/fs_read.rb
 - lib/brute/tools/fs_remove.rb
@@ -252,11 +247,20 @@ files:
 - lib/brute/tools/net_fetch.rb
 - lib/brute/tools/question.rb
 - lib/brute/tools/shell.rb
+- lib/brute/tools/skill_load.rb
+- lib/brute/tools/sub_agent.rb
+- lib/brute/tools/todo_list/store.rb
 - lib/brute/tools/todo_read.rb
 - lib/brute/tools/todo_write.rb
 - lib/brute/truncation.rb
+- lib/brute/turn/agent_pipeline.rb
+- lib/brute/turn/pipeline.rb
+- lib/brute/turn/tool_pipeline.rb
 - lib/brute/utils/diff.rb
 - lib/brute/version.rb
+- lib/brute_cli/providers/shell.rb
+- lib/brute_cli/providers/shell_response.rb
+- lib/ruby_llm/message_transport.rb
 homepage: https://github.com/general-intelligence-systems/brute
 licenses:
 - MIT
@@ -276,7 +280,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A coding agent built on ruby_llm
 test_files: []