brute 1.0.0 → 2.0.0

data/lib/brute/prompts.rb

@@ -1,26 +1,26 @@
-require_relative 'prompts/base'
-require_relative 'prompts/identity'
-require_relative 'prompts/tone_and_style'
-require_relative 'prompts/objectivity'
-require_relative 'prompts/task_management'
-require_relative 'prompts/doing_tasks'
-require_relative 'prompts/tool_usage'
-require_relative 'prompts/conventions'
-require_relative 'prompts/git_safety'
-require_relative 'prompts/code_references'
-require_relative 'prompts/environment'
-require_relative 'prompts/instructions'
-require_relative 'prompts/editing_approach'
-require_relative 'prompts/autonomy'
-require_relative 'prompts/editing_constraints'
-require_relative 'prompts/frontend_tasks'
-require_relative 'prompts/proactiveness'
-require_relative 'prompts/code_style'
-require_relative 'prompts/security_and_safety'
-require_relative 'prompts/skills'
-require_relative 'prompts/plan_reminder'
-require_relative 'prompts/max_steps'
-require_relative 'prompts/build_switch'
+require 'brute/prompts/base'
+require 'brute/prompts/identity'
+require 'brute/prompts/tone_and_style'
+require 'brute/prompts/objectivity'
+require 'brute/prompts/task_management'
+require 'brute/prompts/doing_tasks'
+require 'brute/prompts/tool_usage'
+require 'brute/prompts/conventions'
+require 'brute/prompts/git_safety'
+require 'brute/prompts/code_references'
+require 'brute/prompts/environment'
+require 'brute/prompts/instructions'
+require 'brute/prompts/editing_approach'
+require 'brute/prompts/autonomy'
+require 'brute/prompts/editing_constraints'
+require 'brute/prompts/frontend_tasks'
+require 'brute/prompts/proactiveness'
+require 'brute/prompts/code_style'
+require 'brute/prompts/security_and_safety'
+require 'brute/prompts/skills'
+require 'brute/prompts/plan_reminder'
+require 'brute/prompts/max_steps'
+require 'brute/prompts/build_switch'
 
 module Brute
   module Prompts

data/lib/brute/providers/shell.rb

@@ -29,15 +29,10 @@ module Brute
         "nix"    => ->(cmd) { "nix eval --expr #{Shellwords.escape(cmd)}" },
       }.freeze
 
-      # ── LLM::Provider duck-type interface ──────────────────────────
+      # ── Provider interface ─────────────────────────────────────────
 
       def name           = :shell
       def default_model  = "bash"
-      def user_role      = :user
-      def tool_role      = :tool
-      def assistant_role = :assistant
-      def system_role    = :system
-      def tracer         = LLM::Tracer::Null.new(self)
 
       def complete(prompt, params = {})
         model = params[:model]&.to_s || default_model
@@ -63,28 +58,20 @@ module Brute
 
       private
 
-      # Extract the user's text from whatever prompt format ctx.talk sends.
-      # Returns nil when the prompt contains tool results (the second
+      # Extract the user's text from the messages array.
+      # Returns nil when the messages contain tool results (the second
       # round-trip) so #complete knows to return an empty response.
       def extract_text(prompt)
         case prompt
         when String
           prompt
         when ::Array
-          return nil if prompt.any? { |p| LLM::Function::Return === p }
+          return nil if prompt.any? { |m| m.respond_to?(:role) && m.role == :tool }
 
-          user_msg = prompt.reverse_each.find { |m| m.respond_to?(:role) && m.role.to_s == "user" }
+          user_msg = prompt.reverse_each.find { |m| m.respond_to?(:role) && m.role == :user }
           user_msg&.content.to_s
         else
-          if prompt.respond_to?(:to_a)
-            msgs = prompt.to_a
-            return nil if msgs.any? { |m| m.respond_to?(:content) && LLM::Function::Return === m.content }
-
-            user_msg = msgs.reverse_each.find { |m| m.respond_to?(:role) && m.role.to_s == "user" }
-            user_msg&.content.to_s
-          else
-            prompt.to_s
-          end
+          prompt.to_s
         end
       end
 

data/lib/brute/providers/shell_response.rb

@@ -29,24 +29,20 @@ module Brute
       def messages
         return [empty_assistant] if @command.nil?
 
-        call_id    = "shell_#{SecureRandom.hex(8)}"
-        tool_call  = LLM::Object.from(
-          id: call_id,
-          name: "shell",
-          arguments: { "command" => @command },
-        )
-        original = [{
-          "type"  => "tool_use",
-          "id"    => call_id,
-          "name"  => "shell",
-          "input" => { "command" => @command },
-        }]
-
-        [LLM::Message.new(:assistant, "", {
-          tool_calls: [tool_call],
-          original_tool_calls: original,
-          tools: @tools,
-        })]
+        call_id = "shell_#{SecureRandom.hex(8)}"
+        tool_calls = {
+          call_id => RubyLLM::ToolCall.new(
+            id: call_id,
+            name: "shell",
+            arguments: { "command" => @command },
+          )
+        }
+
+        [RubyLLM::Message.new(
+          role: :assistant,
+          content: "",
+          tool_calls: tool_calls,
+        )]
       end
       alias_method :choices, :messages
 
@@ -71,11 +67,12 @@ module Brute
       end
 
       def content
-        messages.find(&:assistant?)&.content
+        msg = messages.find { |m| m.role == :assistant }
+        msg&.content
       end
 
       def content!
-        LLM.json.load(content)
+        JSON.parse(content)
       end
 
       def reasoning_content
@@ -83,22 +80,17 @@ module Brute
       end
 
       def usage
-        LLM::Usage.new(
-          input_tokens: 0,
-          output_tokens: 0,
-          reasoning_tokens: 0,
-          total_tokens: 0,
+        RubyLLM::Tokens.new(
+          input: 0,
+          output: 0,
+          reasoning: 0,
         )
       end
 
-      # Contract must be included AFTER method definitions —
-      # LLM::Contract checks that all required methods exist at include time.
-      include LLM::Contract::Completion
-
       private
 
       def empty_assistant
-        LLM::Message.new(:assistant, "")
+        RubyLLM::Message.new(role: :assistant, content: "")
       end
     end
   end

data/lib/brute/session.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Brute
+  class Session < Array
+    attr_reader :path
+
+    def initialize(path: nil)
+      super()
+      @path = path
+      FileUtils.mkdir_p(File.dirname(@path)) if @path
+    end
+
+    # Load a session from a JSONL file. Subsequent appends will persist
+    # back to the same file automatically.
+    def self.from_jsonl(path)
+      new(path: path).tap do |session|
+        if File.exist?(path)
+          File.foreach(path).map(&:strip).each do |line|
+            if line.present?
+              # Use push to bypass << persistence (avoids re-writing existing lines)
+              session.push(RubyLLM::Message.new(**JSON.parse(line, symbolize_names: true)))
+            end
+          end
+        end
+      end
+    end
+
+    # Append a message and persist it to disk if a path is set.
+    def <<(msg)
+      super
+      if @path
+        File.open(@path, "a") { |f| f.puts(JSON.generate(msg.to_h)) }
+      end
+      self
+    end
+
+    def user(content)
+      self << RubyLLM::Message.new(role: :user, content: content)
+    end
+
+    def assistant(content)
+      self << RubyLLM::Message.new(role: :assistant, content: content)
+    end
+
+    def system(content)
+      self << RubyLLM::Message.new(role: :system, content: content)
+    end
+  end
+end

data/lib/brute/store/snapshot_store.rb

@@ -2,50 +2,34 @@
 
 module Brute
   module Store
-  # Copy-on-write snapshot storage for file undo support.
-  # Saves the previous content of a file before mutation so it can be restored.
-  # Each file maintains a stack of snapshots, supporting multiple undo levels.
-  module SnapshotStore
-    @store = {}
-    @mutex = Mutex.new
+    # Per-path stack of file snapshots used by fs_write, fs_patch, fs_remove
+    # to enable undo. Each call to .save pushes the current content (or
+    # :did_not_exist for new files). .pop retrieves the most recent snapshot.
+    module SnapshotStore
+      @snapshots = Hash.new { |h, k| h[k] = [] }
+      @mutex     = Mutex.new
 
-    class << self
-      # Save the current state of a file before mutating it.
-      # If the file doesn't exist, records :did_not_exist so undo can delete it.
-      def save(path)
-        path = File.expand_path(path)
-        @mutex.synchronize do
-          @store[path] ||= []
-          if File.exist?(path)
-            @store[path].push(File.read(path))
-          else
-            @store[path].push(:did_not_exist)
-          end
+      class << self
+        # Push the current content of +path+ onto the snapshot stack.
+        # If the file doesn't exist yet, records +:did_not_exist+.
+        def save(path)
+          key = File.expand_path(path)
+          content = File.exist?(key) ? File.read(key) : :did_not_exist
+          @mutex.synchronize { @snapshots[key].push(content) }
         end
-      end
 
-      # Pop the most recent snapshot for a file.
-      # Returns the content string, :did_not_exist, or nil if no history.
-      def pop(path)
-        path = File.expand_path(path)
-        @mutex.synchronize do
-          @store[path]&.pop
+        # Pop and return the most recent snapshot for +path+, or +nil+
+        # if there is no history.
+        def pop(path)
+          key = File.expand_path(path)
+          @mutex.synchronize { @snapshots[key].pop }
         end
-      end
 
-      # Check how many undo levels are available for a file.
-      def depth(path)
-        path = File.expand_path(path)
-        @mutex.synchronize do
-          @store[path]&.size || 0
+        # Clear all snapshots. Used in tests and session resets.
+        def clear!
+          @mutex.synchronize { @snapshots.clear }
         end
       end
-
-      # Clear all snapshots (useful for testing or session reset).
-      def clear!
-        @mutex.synchronize { @store.clear }
-      end
     end
   end
-  end
 end

data/lib/brute/sub_agent.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require 'brute/pipeline'
+
+module Brute
+  # A SubAgent is an Agent that exposes a tool-shaped facade so it can
+  # be dropped into another agent's tools list. The parent agent's
+  # LLMCall passes it to ruby_llm as a regular tool; when invoked, the
+  # SubAgent runs its own pipeline against a fresh Session built from
+  # the tool arguments, then returns the final assistant message as the
+  # tool result.
+  #
+  # Usage:
+  #
+  #   researcher = Brute::SubAgent.new(
+  #     name:        "research",
+  #     description: "Delegate a research task to a read-only sub-agent.",
+  #     provider:    Brute.provider,
+  #     model:       Brute.provider.default_model,
+  #     tools:       [Brute::Tools::FSRead, Brute::Tools::FSSearch],
+  #   ) do
+  #     use Brute::Middleware::SystemPrompt
+  #     use Brute::Middleware::MaxIterations, max_iterations: 10
+  #     use Brute::Middleware::ToolCall
+  #     run Brute::Middleware::LLMCall.new
+  #   end
+  #
+  #   main_agent = Brute::Agent.new(
+  #     provider: ...,
+  #     tools: [Brute::Tools::FSRead, researcher],   # SubAgent IS a tool
+  #   ) { ... }
+  #
+  class SubAgent < Agent
+    DEFAULT_PARAMS = {
+      task: { type: "string", desc: "A clear, detailed description of the task", required: true },
+    }.freeze
+
+    attr_reader :sub_agent_name, :description, :params
+
+    def initialize(name:, description:, params: DEFAULT_PARAMS, **agent_opts, &block)
+      @sub_agent_name = name.to_s
+      @description    = description
+      @params         = params
+      super(**agent_opts, &block)
+    end
+
+    # Tool-shaped entry point. Builds a session from arguments, runs the
+    # agent loop, returns the last assistant message as a string.
+    def execute(arguments)
+      session = build_session(arguments)
+      call(session)
+      extract_result(session)
+    end
+
+    # Adapter so the parent agent's LLMCall (and ruby_llm) sees this as
+    # a regular tool. ToolCall middleware should call `to_ruby_llm` when
+    # building the tools hash if a tool responds to it.
+    def to_ruby_llm
+      sub = self
+      Class.new(RubyLLM::Tool) do
+        description sub.description
+        sub.params.each { |k, opts| param k, **opts }
+        define_method(:name) { sub.sub_agent_name }
+        define_method(:execute) { |**args| sub.execute(args) }
+      end.new
+    end
+
+    # Lets ToolCall treat SubAgents the same as RubyLLM::Tool instances
+    # without checking respond_to? everywhere.
+    def name
+      @sub_agent_name
+    end
+
+    private
+
+      def build_session(arguments)
+        task = arguments[:task] || arguments["task"]
+        Brute::Session.new.tap { |s| s.user(task) }
+      end
+
+      def extract_result(session)
+        last = session.reverse_each.find do |m|
+          m.role == :assistant && m.content.is_a?(String) && !m.content.empty?
+        end
+        last&.content || "(sub-agent completed but produced no text response)"
+      end
+  end
+end
+
+test do
+  it "exposes a name matching the sub-agent identifier" do
+    sa = Brute::SubAgent.new(name: "research", description: "test", provider: :stub) do
+      run ->(env) { env[:messages].assistant("done") }
+    end
+    sa.name.should == "research"
+  end
+
+  it "execute returns the last assistant message" do
+    sa = Brute::SubAgent.new(name: "research", description: "test", provider: :stub) do
+      run ->(env) { env[:messages].assistant("result text") }
+    end
+    sa.execute(task: "do something").should == "result text"
+  end
+end

data/lib/brute/system_prompt.rb

@@ -181,87 +181,5 @@ module Brute
 end
 
 test do
-  def base_ctx
-    { provider_name: "anthropic", model_name: "test-model", cwd: Dir.pwd,
-      custom_rules: nil, agent: nil, agent_switched: nil, max_steps_reached: nil }
-  end
-
-  it "stores a block and executes it on prepare" do
-    sp = Brute::SystemPrompt.build { |p, ctx| p << "hello #{ctx[:name]}" }
-    sp.prepare(name: "world").to_s.should == "hello world"
-  end
-
-  it "returns a Result with sections" do
-    sp = Brute::SystemPrompt.build { |p, _| p << "section one"; p << "section two" }
-    sp.prepare({}).sections.should == ["section one", "section two"]
-  end
-
-  it "strips nil and empty sections" do
-    sp = Brute::SystemPrompt.build { |p, _| p << "kept"; p << nil; p << ""; p << "also kept" }
-    sp.prepare({}).sections.should == ["kept", "also kept"]
-  end
-
-  it "joins sections with double newlines via to_s" do
-    Brute::SystemPrompt::Result.new(["a", "b", "c"]).to_s.should == "a\n\nb\n\nc"
-  end
-
-  it "reports empty? correctly for empty result" do
-    Brute::SystemPrompt::Result.new([]).empty?.should.be.true
-  end
-
-  it "reports empty? correctly for non-empty result" do
-    Brute::SystemPrompt::Result.new(["a"]).empty?.should.be.false
-  end
-
-  it "falls back to default stack for unknown providers" do
-    builder = Brute::SystemPrompt.default
-    default_r = builder.prepare(base_ctx.merge(provider_name: "default"))
-    unknown_r = builder.prepare(base_ctx.merge(provider_name: "unknown_provider"))
-    unknown_r.sections.size.should == default_r.sections.size
-  end
-
-  it "includes PlanReminder when agent is plan" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(agent: "plan")).to_s.should =~ /READ-ONLY/
-  end
-
-  it "excludes PlanReminder when agent is build" do
-    builder = Brute::SystemPrompt.default
-    (builder.prepare(base_ctx.merge(agent: "build")).to_s =~ /Plan Mode - System Reminder/).should.be.nil
-  end
-
-  it "includes BuildSwitch when agent_switched is build" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(agent_switched: "build")).to_s.should =~ /operational mode has changed/
-  end
-
-  it "excludes BuildSwitch when agent_switched is nil" do
-    builder = Brute::SystemPrompt.default
-    (builder.prepare(base_ctx.merge(agent_switched: nil)).to_s =~ /operational mode has changed/).should.be.nil
-  end
-
-  it "includes MaxSteps when max_steps_reached" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(max_steps_reached: true)).to_s.should =~ /MAXIMUM STEPS REACHED/
-  end
-
-  it "excludes MaxSteps when max_steps_reached is nil" do
-    builder = Brute::SystemPrompt.default
-    (builder.prepare(base_ctx.merge(max_steps_reached: nil)).to_s =~ /MAXIMUM STEPS REACHED/).should.be.nil
-  end
-
-  it "anthropic stack includes conventions" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(provider_name: "anthropic")).to_s.should =~ /Following conventions/
-  end
-
-  it "openai stack includes conventions" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(provider_name: "openai")).to_s.should =~ /Following conventions/
-  end
-
-  it "google stack includes conventions" do
-    builder = Brute::SystemPrompt.default
-    builder.prepare(base_ctx.merge(provider_name: "google")).to_s.should =~ /Following conventions/
-  end
+  # not implemented
 end

data/lib/brute/tool.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require 'brute/pipeline'
+
+module Brute
+  # A Tool is a Pipeline configured for tool execution. The terminal app
+  # does the work; middleware wraps it with concerns like file mutation
+  # queueing, snapshotting, validation, logging.
+  #
+  # Coexists with Brute::Tools::* (which inherit from RubyLLM::Tool).
+  # Use Brute::Tool when you want middleware. Use RubyLLM::Tool subclasses
+  # for simple cases.
+  #
+  # Usage:
+  #
+  #   read = Brute::Tool.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 Tool < Pipeline
+    attr_reader :name, :description, :params
+
+    def initialize(name:, description:, params: {}, &block)
+      @name        = name.to_s
+      @description = description
+      @params      = params
+      super(&block)
+    end
+
+    # Execute the tool. Arguments come in as kwargs; result is whatever
+    # the terminal app puts into env[:result].
+    def call(events: NullSink.new, **arguments)
+      env = {
+        name:      @name,
+        arguments: arguments,
+        result:    nil,
+        events:    events,
+        metadata:  {},
+      }
+      super(env)
+      env[:result]
+    end
+
+    # Adapter so the LLM can call this tool through ruby_llm.
+    # ToolCall middleware checks for to_ruby_llm and uses it if present.
+    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
+
+test do
+  it "exposes name, description, params" do
+    t = Brute::Tool.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::Tool.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" do
+    log = []
+    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::Tool.new(name: "x", description: "x") do
+      use wrap, tag: "a"
+      run ->(env) { env[:metadata][:log] << "core"; env[:result] = :ok }
+    end
+
+    # Pre-seed the log on the env that gets built — tool builds its own env,
+    # so we capture via the middleware metadata channel
+    result = t.call(input: 1)
+    result.should == :ok
+  end
+end