brute 0.4.1 → 1.0.1

data/lib/brute/system_prompt.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
 
 module Brute
   # Deferred system prompt builder.
@@ -110,6 +108,18 @@ module Brute
         Prompts::Instructions,
       ],
 
+      # Ollama — lean stack for local models with smaller context windows
+      "ollama" => [
+        Prompts::Identity,
+        Prompts::ToneAndStyle,
+        Prompts::Conventions,
+        Prompts::DoingTasks,
+        Prompts::ToolUsage,
+        Prompts::GitSafety,
+        Prompts::Environment,
+        Prompts::Instructions,
+      ],
+
       # Fallback — conservative, concise, fewer than 4 lines
       "default" => [
         Prompts::Identity,
@@ -170,211 +180,88 @@ module Brute
   end
 end
 
-if __FILE__ == $0
-  require_relative "../../spec/spec_helper"
-
-  RSpec.describe Brute::SystemPrompt do
-    describe ".build" do
-      it "stores a block and executes it on prepare" do
-        sp = described_class.build do |prompt, ctx|
-          prompt << "hello #{ctx[:name]}"
-        end
-
-        result = sp.prepare(name: "world")
-        expect(result.to_s).to eq("hello world")
-      end
-
-      it "returns a Result with sections" do
-        sp = described_class.build do |prompt, _ctx|
-          prompt << "section one"
-          prompt << "section two"
-        end
-
-        result = sp.prepare({})
-        expect(result.sections).to eq(["section one", "section two"])
-      end
-
-      it "strips nil and empty sections" do
-        sp = described_class.build do |prompt, _ctx|
-          prompt << "kept"
-          prompt << nil
-          prompt << ""
-          prompt << "also kept"
-        end
-
-        result = sp.prepare({})
-        expect(result.sections).to eq(["kept", "also kept"])
-      end
-    end
-
-    describe Brute::SystemPrompt::Result do
-      subject(:result) { described_class.new(["a", "b", "c"]) }
-
-      it "joins sections with double newlines via to_s" do
-        expect(result.to_s).to eq("a\n\nb\n\nc")
-      end
-
-      it "iterates over sections via each" do
-        collected = []
-        result.each { |s| collected << s }
-        expect(collected).to eq(["a", "b", "c"])
-      end
-
-      it "reports empty? correctly" do
-        expect(described_class.new([]).empty?).to be true
-        expect(result.empty?).to be false
-      end
-    end
-
-    describe ".default" do
-      # Minimal context for all tests — enough to avoid nil errors
-      let(:base_ctx) do
-        {
-          provider_name: "anthropic",
-          model_name: "test-model",
-          cwd: Dir.pwd,
-          custom_rules: nil,
-          agent: nil,
-          agent_switched: nil,
-          max_steps_reached: nil,
-        }
-      end
-
-      let(:builder) { described_class.default }
-
-      # ── Provider stack selection ──
-
-      described_class::STACKS.each_key do |provider|
-        context "with provider '#{provider}'" do
-          it "produces non-empty sections" do
-            ctx = base_ctx.merge(provider_name: provider)
-            result = builder.prepare(ctx)
-            expect(result.sections).not_to be_empty
-            result.sections.each do |section|
-              expect(section).to be_a(String)
-            end
-          end
-        end
-      end
-
-      it "falls back to 'default' stack for unknown providers" do
-        default_result = builder.prepare(base_ctx.merge(provider_name: "default"))
-        unknown_result = builder.prepare(base_ctx.merge(provider_name: "unknown_provider"))
-
-        # Both should produce the same number of sections (same stack)
-        expect(unknown_result.sections.size).to eq(default_result.sections.size)
-      end
-
-      # ── Plan mode conditional ──
-
-      context "when agent is 'plan'" do
-        it "includes PlanReminder" do
-          result = builder.prepare(base_ctx.merge(agent: "plan"))
-          expect(result.to_s).to include("Plan Mode")
-          expect(result.to_s).to include("<system-reminder>")
-          expect(result.to_s).to include("READ-ONLY")
-        end
-      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
 
-      context "when agent is 'build'" do
-        it "does NOT include PlanReminder" do
-          result = builder.prepare(base_ctx.merge(agent: "build"))
-          expect(result.to_s).not_to include("Plan Mode - System Reminder")
-          expect(result.to_s).not_to include("READ-ONLY")
-        end
-      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
 
-      context "when agent is nil" do
-        it "does NOT include PlanReminder" do
-          result = builder.prepare(base_ctx.merge(agent: nil))
-          expect(result.to_s).not_to include("Plan Mode - System Reminder")
-        end
-      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
 
-      # ── Build switch conditional ──
+  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
 
-      context "when agent_switched is 'build'" do
-        it "includes BuildSwitch" do
-          result = builder.prepare(base_ctx.merge(agent_switched: "build"))
-          expect(result.to_s).to include("operational mode has changed from plan to build")
-        end
-      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
 
-      context "when agent_switched is nil" do
-        it "does NOT include BuildSwitch" do
-          result = builder.prepare(base_ctx.merge(agent_switched: nil))
-          expect(result.to_s).not_to include("operational mode has changed")
-        end
-      end
+  it "reports empty? correctly for empty result" do
+    Brute::SystemPrompt::Result.new([]).empty?.should.be.true
+  end
 
-      # ── Max steps conditional ──
+  it "reports empty? correctly for non-empty result" do
+    Brute::SystemPrompt::Result.new(["a"]).empty?.should.be.false
+  end
 
-      context "when max_steps_reached is truthy" do
-        it "includes MaxSteps" do
-          result = builder.prepare(base_ctx.merge(max_steps_reached: true))
-          expect(result.to_s).to include("MAXIMUM STEPS REACHED")
-          expect(result.to_s).to include("Tools are disabled")
-        end
-      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
 
-      context "when max_steps_reached is falsy" do
-        it "does NOT include MaxSteps" do
-          result = builder.prepare(base_ctx.merge(max_steps_reached: nil))
-          expect(result.to_s).not_to include("MAXIMUM STEPS REACHED")
-        end
-      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
 
-      # ── Combined states (mid-session switch scenarios) ──
+  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
 
-      context "plan mode includes PlanReminder but excludes BuildSwitch" do
-        it "contains only plan-specific content" do
-          result = builder.prepare(base_ctx.merge(agent: "plan"))
-          expect(result.to_s).to include("READ-ONLY")
-          expect(result.to_s).not_to include("operational mode has changed")
-        end
-      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
 
-      context "build mode with agent_switched includes BuildSwitch but excludes PlanReminder" do
-        it "contains only build-switch content" do
-          result = builder.prepare(base_ctx.merge(agent: "build", agent_switched: "build"))
-          expect(result.to_s).to include("operational mode has changed from plan to build")
-          expect(result.to_s).not_to include("Plan Mode - System Reminder")
-        end
-      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
 
-      context "plan mode with max_steps_reached includes both" do
-        it "contains both PlanReminder and MaxSteps" do
-          result = builder.prepare(base_ctx.merge(agent: "plan", max_steps_reached: true))
-          expect(result.to_s).to include("READ-ONLY")
-          expect(result.to_s).to include("MAXIMUM STEPS REACHED")
-        end
-      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
 
-      # ── Provider stack composition ──
+  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 expected modules" do
-        result = builder.prepare(base_ctx.merge(provider_name: "anthropic"))
-        text = result.to_s
-        # Anthropic has Identity, Objectivity, Conventions, GitSafety etc.
-        expect(text).to include("Professional objectivity")
-        expect(text).to include("Following conventions")
-        expect(text).to include("Git safety")
-      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 editing-focused modules" do
-        result = builder.prepare(base_ctx.merge(provider_name: "openai"))
-        text = result.to_s
-        # OpenAI has EditingApproach, Autonomy, EditingConstraints
-        expect(text).to include("Following conventions")
-        expect(text).to include("Git safety")
-      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 security module" do
-        result = builder.prepare(base_ctx.merge(provider_name: "google"))
-        text = result.to_s
-        expect(text).to include("Following conventions")
-        expect(text).to include("Git safety")
-      end
-    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
 end

data/lib/brute/tools/delegate.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
 
 module Brute
   module Tools
@@ -63,126 +61,58 @@ module Brute
   end
 end
 
-if __FILE__ == $0
-  require_relative "../../../spec/spec_helper"
-
-  RSpec.describe Brute::Tools::Delegate do
-    let(:provider) { MockProvider.new }
-
-    # Simple stand-in for LLM::Message in context history.
-    FakeMessage = Struct.new(:role, :content) do
-      def assistant?
-        role == :assistant
-      end
-    end
-
-    before do
-      allow(Brute).to receive(:provider).and_return(provider)
-    end
-
-    def fake_context(messages)
-      msgs_obj = Object.new
-      msgs_obj.define_singleton_method(:to_a) { messages }
-      ctx = Object.new
-      ctx.define_singleton_method(:messages) { msgs_obj }
-      ctx
-    end
-
-    describe "#call" do
-      it "returns the sub-agent's text content" do
-        result = described_class.new.call(task: "What files exist?")
-        expect(result).to be_a(Hash)
-        expect(result[:result]).to eq("mock response")
-      end
-    end
-
-    describe "#extract_content" do
-      let(:delegate) { described_class.new }
-
-      it "returns content when response has text" do
-        res = MockResponse.new(content: "analysis complete")
-        context = fake_context([])
-        result = delegate.send(:extract_content, res, context)
-        expect(result).to eq("analysis complete")
-      end
-
-      context "when res.content raises NoMethodError (tool-only response)" do
-        let(:bad_res) do
-          obj = Object.new
-          obj.define_singleton_method(:content) do
-            raise NoMethodError, "undefined method 'content' for nil"
-          end
-          obj
-        end
-
-        it "falls back to the last assistant text in context messages" do
-          context = fake_context([
-            FakeMessage.new(:user, "input"),
-            FakeMessage.new(:assistant, "found the answer"),
-          ])
-
-          result = delegate.send(:extract_content, bad_res, context)
-          expect(result).to eq("found the answer")
-        end
-
-        it "returns fallback text when no assistant messages exist" do
-          context = fake_context([])
-          result = delegate.send(:extract_content, bad_res, context)
-          expect(result).to eq("(sub-agent completed but produced no text response)")
-        end
-
-        it "skips assistant messages with empty content" do
-          context = fake_context([
-            FakeMessage.new(:assistant, "real answer"),
-            FakeMessage.new(:assistant, ""),
-          ])
-
-          result = delegate.send(:extract_content, bad_res, context)
-          expect(result).to eq("real answer")
-        end
+test do
+  require_relative "../../../spec/support/mock_provider"
+  require_relative "../../../spec/support/mock_response"
 
-        it "skips assistant messages with non-string content" do
-          context = fake_context([
-            FakeMessage.new(:assistant, "text answer"),
-            FakeMessage.new(:assistant, [{"type" => "tool_use"}]),
-          ])
+  FakeMsg = Struct.new(:role, :content) do
+    def assistant?; role == :assistant; end
+  end
 
-          result = delegate.send(:extract_content, bad_res, context)
-          expect(result).to eq("text answer")
-        end
-      end
+  def fake_context(messages)
+    msgs_obj = Object.new
+    msgs_obj.define_singleton_method(:to_a) { messages }
+    ctx = Object.new
+    ctx.define_singleton_method(:messages) { msgs_obj }
+    ctx
+  end
 
-      context "when res.content returns nil (empty response)" do
-        let(:nil_res) { Struct.new(:content).new(nil) }
+  delegate = Brute::Tools::Delegate.new
 
-        it "falls back to the last assistant text in context messages" do
-          context = fake_context([
-            FakeMessage.new(:assistant, "previous answer"),
-          ])
+  it "returns content when response has text" do
+    res = MockResponse.new(content: "analysis complete")
+    delegate.send(:extract_content, res, fake_context([])).should == "analysis complete"
+  end
 
-          result = delegate.send(:extract_content, nil_res, context)
-          expect(result).to eq("previous answer")
-        end
+  it "falls back to last assistant text on NoMethodError" do
+    bad_res = Object.new
+    bad_res.define_singleton_method(:content) { raise NoMethodError }
+    ctx = fake_context([FakeMsg.new(:user, "input"), FakeMsg.new(:assistant, "found the answer")])
+    delegate.send(:extract_content, bad_res, ctx).should == "found the answer"
+  end
 
-        it "returns fallback text when no assistant messages exist" do
-          context = fake_context([])
-          result = delegate.send(:extract_content, nil_res, context)
-          expect(result).to eq("(sub-agent completed but produced no text response)")
-        end
-      end
+  it "returns fallback when no assistant messages exist" do
+    bad_res = Object.new
+    bad_res.define_singleton_method(:content) { raise NoMethodError }
+    delegate.send(:extract_content, bad_res, fake_context([])).should == "(sub-agent completed but produced no text response)"
+  end
 
-      context "when res.content returns empty string" do
-        let(:empty_res) { Struct.new(:content).new("") }
+  it "skips assistant messages with empty content" do
+    bad_res = Object.new
+    bad_res.define_singleton_method(:content) { raise NoMethodError }
+    ctx = fake_context([FakeMsg.new(:assistant, "real answer"), FakeMsg.new(:assistant, "")])
+    delegate.send(:extract_content, bad_res, ctx).should == "real answer"
+  end
 
-        it "falls back to the last assistant text in context messages" do
-          context = fake_context([
-            FakeMessage.new(:assistant, "previous answer"),
-          ])
+  it "falls back to last assistant on nil content" do
+    nil_res = Struct.new(:content).new(nil)
+    ctx = fake_context([FakeMsg.new(:assistant, "previous answer")])
+    delegate.send(:extract_content, nil_res, ctx).should == "previous answer"
+  end
 
-          result = delegate.send(:extract_content, empty_res, context)
-          expect(result).to eq("previous answer")
-        end
-      end
-    end
+  it "falls back to last assistant on empty string content" do
+    empty_res = Struct.new(:content).new("")
+    ctx = fake_context([FakeMsg.new(:assistant, "previous answer")])
+    delegate.send(:extract_content, empty_res, ctx).should == "previous answer"
   end
 end

data/lib/brute/tools/fs_patch.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
 
 module Brute
   module Tools
@@ -19,13 +17,13 @@ module Brute
 
       def call(file_path:, old_string:, new_string:, replace_all: false)
         path = File.expand_path(file_path)
-        Brute::FileMutationQueue.serialize(path) do
+        Brute::Queue::FileMutationQueue.serialize(path) do
           raise "File not found: #{path}" unless File.exist?(path)
 
           original = File.read(path)
           raise "old_string not found in #{path}" unless original.include?(old_string)
 
-          Brute::SnapshotStore.save(path)
+          Brute::Store::SnapshotStore.save(path)
 
           updated = if replace_all
                       original.gsub(old_string, new_string)
@@ -43,50 +41,51 @@ module Brute
   end
 end
 
-if __FILE__ == $0
-  require_relative "../../../spec/spec_helper"
-
-  RSpec.describe Brute::Tools::FSPatch do
-    around(:each) { |ex| Dir.mktmpdir { |d| @dir = d; ex.run } }
+test do
+  require "tmpdir"
 
-    let(:tool) { described_class.new }
-
-    it "replaces old_string with new_string" do
-      path = File.join(@dir, "test.rb")
+  it "replaces old_string with new_string" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.rb")
       File.write(path, "hello world\n")
-      result = tool.call(file_path: path, old_string: "world", new_string: "ruby")
-      expect(result[:success]).to be true
-      expect(File.read(path)).to eq("hello ruby\n")
+      result = Brute::Tools::FSPatch.new.call(file_path: path, old_string: "world", new_string: "ruby")
+      File.read(path).should == "hello ruby\n"
     end
+  end
 
-    it "returns a unified diff" do
-      path = File.join(@dir, "test.rb")
+  it "returns a unified diff" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.rb")
       File.write(path, "line1\nold line\nline3\n")
-      result = tool.call(file_path: path, old_string: "old line", new_string: "new line")
-      expect(result[:diff]).to include("-old line")
-      expect(result[:diff]).to include("+new line")
+      result = Brute::Tools::FSPatch.new.call(file_path: path, old_string: "old line", new_string: "new line")
+      result[:diff].should =~ /\-old line/
     end
+  end
 
-    it "raises when file not found" do
-      expect {
-        tool.call(file_path: File.join(@dir, "nope.rb"), old_string: "a", new_string: "b")
-      }.to raise_error(/File not found/)
+  it "raises when file not found" do
+    Dir.mktmpdir do |dir|
+      lambda {
+        Brute::Tools::FSPatch.new.call(file_path: File.join(dir, "nope.rb"), old_string: "a", new_string: "b")
+      }.should.raise(RuntimeError)
     end
+  end
 
-    it "raises when old_string not found" do
-      path = File.join(@dir, "test.rb")
+  it "raises when old_string not found" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.rb")
       File.write(path, "hello\n")
-      expect {
-        tool.call(file_path: path, old_string: "missing", new_string: "new")
-      }.to raise_error(/old_string not found/)
+      lambda {
+        Brute::Tools::FSPatch.new.call(file_path: path, old_string: "missing", new_string: "new")
+      }.should.raise(RuntimeError)
     end
+  end
 
-    it "supports replace_all" do
-      path = File.join(@dir, "test.rb")
+  it "supports replace_all" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "test.rb")
       File.write(path, "aaa bbb aaa\n")
-      result = tool.call(file_path: path, old_string: "aaa", new_string: "ccc", replace_all: true)
-      expect(result[:replacements]).to eq(2)
-      expect(File.read(path)).to eq("ccc bbb ccc\n")
+      result = Brute::Tools::FSPatch.new.call(file_path: path, old_string: "aaa", new_string: "ccc", replace_all: true)
+      result[:replacements].should == 2
     end
   end
 end

data/lib/brute/tools/fs_remove.rb

@@ -17,10 +17,10 @@ module Brute
 
       def call(path:)
         target = File.expand_path(path)
-        Brute::FileMutationQueue.serialize(target) do
+        Brute::Queue::FileMutationQueue.serialize(target) do
           raise "Path not found: #{target}" unless File.exist?(target)
 
-          Brute::SnapshotStore.save(target) if File.file?(target)
+          Brute::Store::SnapshotStore.save(target) if File.file?(target)
 
           if File.directory?(target)
             Dir.rmdir(target)

data/lib/brute/tools/fs_undo.rb

@@ -16,8 +16,8 @@ module Brute
 
       def call(path:)
         target = File.expand_path(path)
-        Brute::FileMutationQueue.serialize(target) do
-          snapshot = Brute::SnapshotStore.pop(target)
+        Brute::Queue::FileMutationQueue.serialize(target) do
+          snapshot = Brute::Store::SnapshotStore.pop(target)
           raise "No undo history available for: #{target}" unless snapshot
 
           if snapshot == :did_not_exist