brute 0.4.0 → 0.4.1

data/lib/brute/middleware/tracing.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+if __FILE__ == $0
+  require "bundler/setup"
+  require "brute"
+end
+
 module Brute
   module Middleware
     # Logs timing and token usage for every LLM call, and tracks cumulative
@@ -61,3 +66,69 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Middleware::Tracing do
+    let(:response) { MockResponse.new(content: "traced response") }
+    let(:inner_app) { ->(_env) { response } }
+    let(:log_output) { StringIO.new }
+    let(:logger) { Logger.new(log_output) }
+    let(:middleware) { described_class.new(inner_app, logger: logger) }
+
+    it "passes the response through unchanged" do
+      env = build_env(tool_results: nil)
+      result = middleware.call(env)
+      expect(result).to eq(response)
+    end
+
+    it "populates env[:metadata][:timing] with all required keys" do
+      env = build_env(tool_results: nil)
+      middleware.call(env)
+
+      timing = env[:metadata][:timing]
+      expect(timing).to include(
+        :total_elapsed,
+        :total_llm_elapsed,
+        :llm_call_count,
+        :last_call_elapsed
+      )
+      expect(timing[:llm_call_count]).to eq(1)
+      expect(timing[:last_call_elapsed]).to be >= 0
+      expect(timing[:total_llm_elapsed]).to be >= 0
+    end
+
+    it "resets turn timing when tool_results is nil (new turn)" do
+      env = build_env(tool_results: nil)
+      middleware.call(env)
+      first_elapsed = env[:metadata][:timing][:total_llm_elapsed]
+
+      # Simulate continuation within the same turn (tool_results present)
+      env[:tool_results] = [["read", { content: "file data" }]]
+      middleware.call(env)
+
+      expect(env[:metadata][:timing][:llm_call_count]).to eq(2)
+      expect(env[:metadata][:timing][:total_llm_elapsed]).to be >= first_elapsed
+    end
+
+    it "accumulates call count across multiple calls" do
+      env = build_env(tool_results: nil)
+      middleware.call(env)
+      env[:tool_results] = [["read", {}]]
+      middleware.call(env)
+      middleware.call(env)
+
+      expect(env[:metadata][:timing][:llm_call_count]).to eq(3)
+    end
+
+    it "logs debug and info messages" do
+      env = build_env(tool_results: nil)
+      middleware.call(env)
+
+      log_text = log_output.string
+      expect(log_text).to include("LLM call #1")
+      expect(log_text).to include("LLM response #1")
+    end
+  end
+end

data/lib/brute/orchestrator.rb

@@ -111,7 +111,7 @@ module Brute
     # Returns the final assistant response.
     def run(user_message)
       unless @provider
-        raise "No LLM provider configured. Set LLM_API_KEY and optionally LLM_PROVIDER (default: anthropic)"
+        raise "No LLM provider configured. Set LLM_API_KEY and optionally LLM_PROVIDER (default: opencode_zen)"
       end
 
       @request_count = 0
@@ -389,3 +389,162 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../spec/spec_helper"
+
+  RSpec.describe Brute::Orchestrator, "system prompt" do
+    let(:provider) { MockProvider.new }
+
+    def build_orchestrator(agent_name: nil, cwd: Dir.pwd)
+      described_class.new(
+        provider: provider,
+        model: "test-model",
+        tools: [],
+        cwd: cwd,
+        agent_name: agent_name,
+        logger: Logger.new(File::NULL),
+      )
+    end
+
+    def system_prompt_for(orchestrator)
+      orchestrator.instance_variable_get(:@system_prompt)
+    end
+
+    # ── Build mode (default) ──
+
+    context "build mode (default, agent_name: nil)" do
+      subject(:prompt) { system_prompt_for(build_orchestrator(agent_name: nil)) }
+
+      it "does NOT contain PlanReminder" do
+        expect(prompt).not_to include("Plan Mode - System Reminder")
+        expect(prompt).not_to include("READ-ONLY")
+      end
+
+      it "does NOT contain BuildSwitch" do
+        expect(prompt).not_to include("operational mode has changed")
+      end
+
+      it "does NOT contain MaxSteps" do
+        expect(prompt).not_to include("MAXIMUM STEPS REACHED")
+      end
+
+      it "contains identity section" do
+        expect(prompt).to include("Brute")
+      end
+
+      it "contains environment section" do
+        expect(prompt).to include("<env>")
+        expect(prompt).to include("Working directory:")
+      end
+    end
+
+    context "build mode (explicit agent_name: 'build')" do
+      subject(:prompt) { system_prompt_for(build_orchestrator(agent_name: "build")) }
+
+      it "does NOT contain PlanReminder" do
+        expect(prompt).not_to include("Plan Mode - System Reminder")
+        expect(prompt).not_to include("READ-ONLY")
+      end
+
+      it "contains identity section" do
+        expect(prompt).to include("Brute")
+      end
+    end
+
+    # ── Plan mode ──
+
+    context "plan mode (agent_name: 'plan')" do
+      subject(:prompt) { system_prompt_for(build_orchestrator(agent_name: "plan")) }
+
+      it "includes PlanReminder" do
+        expect(prompt).to include("Plan Mode - System Reminder")
+        expect(prompt).to include("<system-reminder>")
+        expect(prompt).to include("READ-ONLY")
+      end
+
+      it "includes the supersede warning" do
+        expect(prompt).to include("supersedes any other instructions")
+      end
+
+      it "does NOT include BuildSwitch" do
+        expect(prompt).not_to include("operational mode has changed")
+      end
+
+      it "still includes identity section" do
+        expect(prompt).to include("Brute")
+      end
+
+      it "still includes environment section" do
+        expect(prompt).to include("<env>")
+      end
+    end
+
+    # ── Switching from plan to build (simulating mid-session agent recreation) ──
+
+    context "switching from plan to build (new orchestrator, same session)" do
+      let(:session) { Brute::Session.new }
+
+      it "plan orchestrator has PlanReminder, build orchestrator does not" do
+        plan_orch = described_class.new(
+          provider: provider,
+          model: "test-model",
+          tools: [],
+          session: session,
+          agent_name: "plan",
+          logger: Logger.new(File::NULL),
+        )
+        plan_prompt = system_prompt_for(plan_orch)
+        expect(plan_prompt).to include("READ-ONLY")
+
+        build_orch = described_class.new(
+          provider: provider,
+          model: "test-model",
+          tools: [],
+          session: session,
+          agent_name: "build",
+          logger: Logger.new(File::NULL),
+        )
+        build_prompt = system_prompt_for(build_orch)
+        expect(build_prompt).not_to include("READ-ONLY")
+        expect(build_prompt).not_to include("Plan Mode")
+      end
+
+      it "build orchestrator does NOT contain BuildSwitch (agent_switched never set)" do
+        build_orch = described_class.new(
+          provider: provider,
+          model: "test-model",
+          tools: [],
+          session: session,
+          agent_name: "build",
+          logger: Logger.new(File::NULL),
+        )
+        build_prompt = system_prompt_for(build_orch)
+        # This documents the current behavior: BuildSwitch is dead code
+        expect(build_prompt).not_to include("operational mode has changed from plan to build")
+      end
+    end
+
+    # ── Provider-specific stacks ──
+
+    context "provider-specific identity text" do
+      it "uses mock provider (falls back to default stack)" do
+        prompt = system_prompt_for(build_orchestrator)
+        # MockProvider.name returns :mock, which isn't a known stack, so falls back to "default"
+        expect(prompt).to be_a(String)
+        expect(prompt).not_to be_empty
+      end
+    end
+
+    # ── Working directory is embedded ──
+
+    context "cwd propagation" do
+      it "embeds the given cwd in the system prompt" do
+        Dir.mktmpdir do |dir|
+          prompt = system_prompt_for(build_orchestrator(cwd: dir))
+          expect(prompt).to include(dir)
+        end
+      end
+    end
+  end
+end

data/lib/brute/patches/buffer_nil_guard.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+if __FILE__ == $0
+  require "bundler/setup"
+  require "brute"
+end
+
 # Monkey-patch: Guard LLM::Buffer against nil entries.
 #
 # llm.rb's Context#talk can sometimes concatenate nil into the message

data/lib/brute/pipeline.rb

@@ -79,3 +79,138 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../spec/spec_helper"
+
+  RSpec.describe "Middleware Pipeline Integration" do
+    let(:provider) { MockProvider.new }
+    let(:log_output) { StringIO.new }
+    let(:logger) { Logger.new(log_output) }
+    let(:session) { double("session", save: nil) }
+    let(:compactor) { double("compactor", should_compact?: false) }
+
+    describe "full orchestrator pipeline" do
+      it "passes env through all middleware and returns the response" do
+        response = MockResponse.new(content: "integrated response")
+        allow(provider).to receive(:complete).and_return(response)
+
+        ctx = LLM::Context.new(provider, tools: [])
+        prompt = ctx.prompt { |p| p.system("sys"); p.user("hello") }
+
+        pipeline = Brute::Pipeline.new
+        pipeline.use(Brute::Middleware::Tracing, logger: logger)
+        pipeline.use(Brute::Middleware::Retry, max_attempts: 3, base_delay: 2)
+        pipeline.use(Brute::Middleware::SessionPersistence, session: session)
+        pipeline.use(Brute::Middleware::TokenTracking)
+        pipeline.use(Brute::Middleware::CompactionCheck, compactor: compactor, system_prompt: "sys", tools: [])
+        pipeline.use(Brute::Middleware::ToolErrorTracking)
+        pipeline.use(Brute::Middleware::DoomLoopDetection, threshold: 3)
+        pipeline.use(Brute::Middleware::ToolUseGuard)
+        pipeline.run(Brute::Middleware::LLMCall.new)
+
+        env = {
+          context: ctx,
+          provider: provider,
+          input: prompt,
+          tools: [],
+          params: {},
+          metadata: {},
+          callbacks: {},
+          tool_results: nil,
+          streaming: false,
+        }
+
+        result = pipeline.call(env)
+
+        expect(result).not_to be_nil
+        expect(env[:metadata][:timing]).to include(:llm_call_count, :total_llm_elapsed)
+        expect(env[:metadata][:tokens]).to include(:total_input, :total_output, :call_count)
+        expect(session).to have_received(:save)
+        expect(log_output.string).to include("LLM call #1")
+      end
+    end
+
+    describe "Retry + Tracing combo" do
+      it "Tracing sees the full elapsed time including retries" do
+        call_count = 0
+        response = MockResponse.new(content: "recovered")
+
+        allow(provider).to receive(:complete) do |*_args|
+          call_count += 1
+          raise LLM::RateLimitError, "rate limited" if call_count <= 1
+          response
+        end
+
+        ctx = LLM::Context.new(provider, tools: [])
+        prompt = ctx.prompt { |p| p.system("sys"); p.user("hi") }
+
+        pipeline = Brute::Pipeline.new
+        pipeline.use(Brute::Middleware::Tracing, logger: logger)
+        pipeline.use(Brute::Middleware::Retry, max_attempts: 3, base_delay: 0)
+        pipeline.run(Brute::Middleware::LLMCall.new)
+
+        env = {
+          context: ctx,
+          provider: provider,
+          input: prompt,
+          tools: [],
+          params: {},
+          metadata: {},
+          callbacks: {},
+          tool_results: nil,
+          streaming: false,
+        }
+
+        result = pipeline.call(env)
+
+        expect(result).not_to be_nil
+        expect(env[:metadata][:timing][:llm_call_count]).to eq(1)
+      end
+    end
+
+    describe "TokenTracking + SessionPersistence combo" do
+      it "session receives save after tokens are tracked" do
+        response = MockResponse.new(content: "tracked and saved")
+        allow(provider).to receive(:complete).and_return(response)
+
+        ctx = LLM::Context.new(provider, tools: [])
+        prompt = ctx.prompt { |p| p.system("sys"); p.user("hi") }
+
+        save_args = []
+        allow(session).to receive(:save) { |ctx_arg| save_args << ctx_arg }
+
+        pipeline = Brute::Pipeline.new
+        pipeline.use(Brute::Middleware::SessionPersistence, session: session)
+        pipeline.use(Brute::Middleware::TokenTracking)
+        pipeline.run(Brute::Middleware::LLMCall.new)
+
+        env = {
+          context: ctx,
+          provider: provider,
+          input: prompt,
+          tools: [],
+          params: {},
+          metadata: {},
+          callbacks: {},
+          tool_results: nil,
+          streaming: false,
+        }
+
+        pipeline.call(env)
+
+        expect(env[:metadata][:tokens]).to include(:total_input)
+        expect(save_args.size).to eq(1)
+      end
+    end
+
+    describe "Pipeline builder" do
+      it "raises when no terminal app is set" do
+        pipeline = Brute::Pipeline.new
+        pipeline.use(Brute::Middleware::TokenTracking)
+
+        expect { pipeline.call({}) }.to raise_error(RuntimeError, /no terminal app/)
+      end
+    end
+  end
+end

data/lib/brute/prompts/build_switch.rb

@@ -17,3 +17,36 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::BuildSwitch do
+    subject(:text) { described_class.call({}) }
+
+    it "returns a string" do
+      expect(text).to be_a(String)
+    end
+
+    it "wraps content in system-reminder tags" do
+      expect(text).to include("<system-reminder>")
+      expect(text).to include("</system-reminder>")
+    end
+
+    it "announces the mode change from plan to build" do
+      expect(text).to include("plan to build")
+    end
+
+    it "states the agent is no longer in read-only mode" do
+      expect(text).to include("no longer in read-only mode")
+    end
+
+    it "permits tool use" do
+      expect(text).to include("permitted to make file changes")
+    end
+
+    it "ignores context (static content)" do
+      expect(described_class.call({ agent_switched: "build" })).to eq(described_class.call({}))
+    end
+  end
+end

data/lib/brute/prompts/environment.rb

@@ -23,3 +23,50 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::Environment do
+    it "includes cwd from context" do
+      text = described_class.call(cwd: "/some/path", model_name: "test")
+      expect(text).to include("/some/path")
+    end
+
+    it "includes model name from context" do
+      text = described_class.call(cwd: "/tmp", model_name: "claude-sonnet-4-20250514")
+      expect(text).to include("claude-sonnet-4-20250514")
+    end
+
+    it "wraps environment info in <env> tags" do
+      text = described_class.call(cwd: "/tmp", model_name: "test")
+      expect(text).to include("<env>")
+      expect(text).to include("</env>")
+    end
+
+    it "detects git repo when .git exists" do
+      Dir.mktmpdir do |dir|
+        Dir.mkdir(File.join(dir, ".git"))
+        text = described_class.call(cwd: dir, model_name: "test")
+        expect(text).to include("Is directory a git repo: yes")
+      end
+    end
+
+    it "detects non-git directory" do
+      Dir.mktmpdir do |dir|
+        text = described_class.call(cwd: dir, model_name: "test")
+        expect(text).to include("Is directory a git repo: no")
+      end
+    end
+
+    it "includes the platform" do
+      text = described_class.call(cwd: "/tmp", model_name: "test")
+      expect(text).to include(RUBY_PLATFORM)
+    end
+
+    it "defaults cwd to Dir.pwd when not provided" do
+      text = described_class.call(model_name: "test")
+      expect(text).to include(Dir.pwd)
+    end
+  end
+end

data/lib/brute/prompts/identity.rb

@@ -9,3 +9,39 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::Identity do
+    it "returns provider-specific text for anthropic" do
+      text = described_class.call(provider_name: "anthropic")
+      expect(text).to be_a(String)
+      expect(text).not_to be_empty
+    end
+
+    it "returns provider-specific text for openai" do
+      text = described_class.call(provider_name: "openai")
+      expect(text).to be_a(String)
+      expect(text).not_to be_empty
+    end
+
+    it "returns provider-specific text for google" do
+      text = described_class.call(provider_name: "google")
+      expect(text).to be_a(String)
+      expect(text).not_to be_empty
+    end
+
+    it "falls back to default.txt for unknown providers" do
+      default_text = described_class.call(provider_name: "default")
+      unknown_text = described_class.call(provider_name: "nonexistent_provider")
+      expect(unknown_text).to eq(default_text)
+    end
+
+    it "returns different text for different providers" do
+      anthropic = described_class.call(provider_name: "anthropic")
+      openai = described_class.call(provider_name: "openai")
+      expect(anthropic).not_to eq(openai)
+    end
+  end
+end

data/lib/brute/prompts/instructions.rb

@@ -16,3 +16,27 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::Instructions do
+    it "returns nil when custom_rules is nil" do
+      expect(described_class.call(custom_rules: nil)).to be_nil
+    end
+
+    it "returns nil when custom_rules is empty" do
+      expect(described_class.call(custom_rules: "")).to be_nil
+    end
+
+    it "returns nil when custom_rules is whitespace-only" do
+      expect(described_class.call(custom_rules: "   \n  ")).to be_nil
+    end
+
+    it "wraps custom_rules in a Project-Specific Rules header" do
+      text = described_class.call(custom_rules: "Always use tabs.")
+      expect(text).to include("Project-Specific Rules")
+      expect(text).to include("Always use tabs.")
+    end
+  end
+end

data/lib/brute/prompts/max_steps.rb

@@ -28,3 +28,35 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::MaxSteps do
+    subject(:text) { described_class.call({}) }
+
+    it "returns a string" do
+      expect(text).to be_a(String)
+    end
+
+    it "announces maximum steps reached" do
+      expect(text).to include("MAXIMUM STEPS REACHED")
+    end
+
+    it "states tools are disabled" do
+      expect(text).to include("Tools are disabled")
+    end
+
+    it "requires a text-only response" do
+      expect(text).to include("text ONLY")
+    end
+
+    it "requires summary of work done" do
+      expect(text).to include("Summary of what has been accomplished")
+    end
+
+    it "ignores context (static content)" do
+      expect(described_class.call({ max_steps_reached: true })).to eq(described_class.call({}))
+    end
+  end
+end

data/lib/brute/prompts/plan_reminder.rb

@@ -38,3 +38,36 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::PlanReminder do
+    subject(:text) { described_class.call({}) }
+
+    it "returns a string" do
+      expect(text).to be_a(String)
+    end
+
+    it "wraps content in system-reminder tags" do
+      expect(text).to include("<system-reminder>")
+      expect(text).to include("</system-reminder>")
+    end
+
+    it "declares READ-ONLY mode" do
+      expect(text).to include("READ-ONLY")
+    end
+
+    it "forbids file edits" do
+      expect(text).to include("STRICTLY FORBIDDEN")
+    end
+
+    it "states it supersedes other instructions" do
+      expect(text).to include("supersedes any other instructions")
+    end
+
+    it "ignores context (static content)" do
+      expect(described_class.call({ agent: "plan" })).to eq(described_class.call({}))
+    end
+  end
+end

data/lib/brute/prompts/skills.rb

@@ -20,3 +20,38 @@ module Brute
     end
   end
 end
+
+if __FILE__ == $0
+  require_relative "../../../spec/spec_helper"
+
+  RSpec.describe Brute::Prompts::Skills do
+    it "returns nil when no skills are found" do
+      Dir.mktmpdir do |dir|
+        text = described_class.call(cwd: dir)
+        expect(text).to be_nil
+      end
+    end
+
+    it "lists discovered skills when present" do
+      Dir.mktmpdir do |dir|
+        # Create a minimal SKILL.md file
+        skill_dir = File.join(dir, ".brute", "skills")
+        FileUtils.mkdir_p(skill_dir)
+        File.write(File.join(skill_dir, "SKILL.md"), <<~MD)
+          ---
+          name: test-skill
+          description: A test skill
+          ---
+          # Test Skill Content
+        MD
+
+        text = described_class.call(cwd: dir)
+        if text
+          expect(text).to include("skill")
+        else
+          skip "Skill discovery does not find skills in .brute/skills/"
+        end
+      end
+    end
+  end
+end

data/lib/brute/providers/opencode_go.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+if __FILE__ == $0
+  require "bundler/setup"
+  require "brute"
+end
+
 module LLM
   ##
   # OpenAI-compatible provider for the OpenCode Go API gateway.