brute 0.4.0 → 1.0.0

data/lib/brute/{message_store.rb → store/message_store.rb}

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "brute"
 require "json"
 require "fileutils"
 require "securerandom"
 
 module Brute
+  module Store
   # Stores session messages as individual JSON files in the OpenCode
   # {info, parts} format. Each session gets a directory; each message
   # is a numbered JSON file inside it.
@@ -35,9 +38,6 @@ module Brute
       load_existing
     end
 
-    # ── Append messages ──────────────────────────────────────────────
-
-    # Record a user message.
     def append_user(text:, message_id: nil)
       id = message_id || next_message_id
       msg = {
@@ -56,8 +56,6 @@ module Brute
       id
     end
 
-    # Record the start of an assistant message. Returns the message ID.
-    # Call complete_assistant later to fill in tokens/timing.
     def append_assistant(message_id: nil, parent_id: nil, model_id: nil, provider_id: nil)
       id = message_id || next_message_id
       msg = {
@@ -78,9 +76,6 @@ module Brute
       id
     end
 
-    # ── Parts ────────────────────────────────────────────────────────
-
-    # Add a text part to an existing message.
     def add_text_part(message_id:, text:)
       @mutex.synchronize do
         msg = @messages[message_id]
@@ -94,7 +89,6 @@ module Brute
       end
     end
 
-    # Add a tool part in "running" state. Returns the part ID.
     def add_tool_part(message_id:, tool:, call_id:, input:)
       @mutex.synchronize do
         msg = @messages[message_id]
@@ -115,7 +109,6 @@ module Brute
       end
     end
 
-    # Mark a tool part as completed with output.
     def complete_tool_part(message_id:, call_id:, output:)
       @mutex.synchronize do
         msg = @messages[message_id]
@@ -131,7 +124,6 @@ module Brute
       end
     end
 
-    # Mark a tool part as errored.
     def error_tool_part(message_id:, call_id:, error:)
       @mutex.synchronize do
         msg = @messages[message_id]
@@ -147,7 +139,6 @@ module Brute
       end
     end
 
-    # Add a step-finish part to an assistant message.
     def add_step_finish(message_id:, tokens: nil)
       @mutex.synchronize do
         msg = @messages[message_id]
@@ -164,8 +155,6 @@ module Brute
       end
     end
 
-    # ── Complete / update ────────────────────────────────────────────
-
     # Finalize an assistant message with token counts and completion time.
     def complete_assistant(message_id:, tokens: nil)
       @mutex.synchronize do
@@ -185,85 +174,189 @@ module Brute
       end
     end
 
-    # ── Queries ──────────────────────────────────────────────────────
-
-    # All messages in order.
     def messages
       @mutex.synchronize { @messages.values }
     end
 
-    # Single message by ID.
     def message(id)
       @mutex.synchronize { @messages[id] }
     end
 
-    # Number of stored messages.
     def count
       @mutex.synchronize { @messages.size }
     end
 
     private
 
-    # ── ID generation ────────────────────────────────────────────────
+      def next_message_id
+        @seq += 1
+        format("msg_%04d", @seq)
+      end
+
+      def next_part_id
+        @part_seq += 1
+        format("prt_%04d", @part_seq)
+      end
+
+      def now_ms
+        (Time.now.to_f * 1000).to_i
+      end
+
+      def save_message(id, msg)
+        @mutex.synchronize do
+          @messages[id] = msg
+          persist(id)
+        end
+      end
+
+      def persist(id)
+        FileUtils.mkdir_p(@dir)
+        msg = @messages[id]
+        return unless msg
+
+        path = File.join(@dir, "#{id}.json")
+        File.write(path, JSON.pretty_generate(msg))
+      end
+
+      def load_existing
+        return unless File.directory?(@dir)
+
+        Dir.glob(File.join(@dir, "msg_*.json")).sort.each do |path|
+          data = JSON.parse(File.read(path), symbolize_names: true)
+          id = data.dig(:info, :id)
+          next unless id
+
+          @messages[id] = data
+
+          # Track sequence numbers so new IDs don't collide
+          if (m = id.match(/\Amsg_(\d+)\z/))
+            n = m[1].to_i
+            @seq = n if n > @seq
+          end
+
+          # Track part sequences too
+          (data[:parts] || []).each do |part|
+            pid = part[:id]
+            if pid.is_a?(String) && (m = pid.match(/\Aprt_(\d+)\z/))
+              n = m[1].to_i
+              @part_seq = n if n > @part_seq
+            end
+          end
+        end
+      end
+  end
+  end
+end
+
+test do
+  require "tmpdir"
+
+  def with_store
+    dir = Dir.mktmpdir("brute_test_")
+    store = Brute::Store::MessageStore.new(session_id: "test-session-123", dir: dir)
+    yield store, dir
+  ensure
+    FileUtils.rm_rf(dir)
+  end
 
-    def next_message_id
-      @seq += 1
-      format("msg_%04d", @seq)
+  it "creates a user message with text part" do
+    with_store do |store, _|
+      id = store.append_user(text: "Hello")
+      store.message(id)[:info][:role].should == "user"
     end
+  end
 
-    def next_part_id
-      @part_seq += 1
-      format("prt_%04d", @part_seq)
+  it "stores user message text" do
+    with_store do |store, _|
+      id = store.append_user(text: "Hello")
+      store.message(id)[:parts][0][:text].should == "Hello"
     end
+  end
 
-    def now_ms
-      (Time.now.to_f * 1000).to_i
+  it "generates sequential message IDs" do
+    with_store do |store, _|
+      id1 = store.append_user(text: "First")
+      id2 = store.append_user(text: "Second")
+      id1.should == "msg_0001"
     end
+  end
 
-    # ── Persistence ──────────────────────────────────────────────────
+  it "creates an assistant message" do
+    with_store do |store, _|
+      uid = store.append_user(text: "Hi")
+      aid = store.append_assistant(parent_id: uid, model_id: "claude", provider_id: "anthropic")
+      store.message(aid)[:info][:role].should == "assistant"
+    end
+  end
 
-    def save_message(id, msg)
-      @mutex.synchronize do
-        @messages[id] = msg
-        persist(id)
-      end
+  it "appends a text part to an existing message" do
+    with_store do |store, _|
+      aid = store.append_assistant
+      store.add_text_part(message_id: aid, text: "Here is my response")
+      store.message(aid)[:parts][0][:text].should == "Here is my response"
     end
+  end
 
-    def persist(id)
-      FileUtils.mkdir_p(@dir)
-      msg = @messages[id]
-      return unless msg
+  it "tracks tool lifecycle running to completed" do
+    with_store do |store, _|
+      aid = store.append_assistant
+      store.add_tool_part(message_id: aid, tool: "read", call_id: "call_001", input: {})
+      store.message(aid)[:parts].find { |p| p[:type] == "tool" }[:state][:status].should == "running"
+      store.complete_tool_part(message_id: aid, call_id: "call_001", output: "done")
+      store.message(aid)[:parts].find { |p| p[:type] == "tool" }[:state][:status].should == "completed"
+    end
+  end
 
-      path = File.join(@dir, "#{id}.json")
-      File.write(path, JSON.pretty_generate(msg))
+  it "tracks tool lifecycle running to error" do
+    with_store do |store, _|
+      aid = store.append_assistant
+      store.add_tool_part(message_id: aid, tool: "shell", call_id: "call_002", input: {})
+      store.error_tool_part(message_id: aid, call_id: "call_002", error: "denied")
+      store.message(aid)[:parts].find { |p| p[:type] == "tool" }[:state][:status].should == "error"
     end
+  end
 
-    # Load any existing message files from disk on init.
-    def load_existing
-      return unless File.directory?(@dir)
+  it "sets token counts on complete_assistant" do
+    with_store do |store, _|
+      aid = store.append_assistant
+      store.complete_assistant(message_id: aid, tokens: { input: 100, output: 50, reasoning: 10, cache: { read: 0, write: 0 } })
+      store.message(aid)[:info][:tokens][:input].should == 100
+    end
+  end
 
-      Dir.glob(File.join(@dir, "msg_*.json")).sort.each do |path|
-        data = JSON.parse(File.read(path), symbolize_names: true)
-        id = data.dig(:info, :id)
-        next unless id
+  it "returns all messages in order" do
+    with_store do |store, _|
+      store.append_user(text: "Q1")
+      store.append_assistant
+      store.append_user(text: "Q2")
+      store.messages.size.should == 3
+    end
+  end
 
-        @messages[id] = data
+  it "returns count of stored messages" do
+    with_store do |store, _|
+      store.count.should == 0
+      store.append_user(text: "Q1")
+      store.count.should == 1
+    end
+  end
 
-        # Track sequence numbers so new IDs don't collide
-        if (m = id.match(/\Amsg_(\d+)\z/))
-          n = m[1].to_i
-          @seq = n if n > @seq
-        end
+  it "restores messages from disk" do
+    with_store do |store, dir|
+      store.append_user(text: "Persisted Q")
+      aid = store.append_assistant(model_id: "claude")
+      store.add_text_part(message_id: aid, text: "Persisted A")
+      store2 = Brute::Store::MessageStore.new(session_id: "test-session-123", dir: dir)
+      store2.count.should == 2
+    end
+  end
 
-        # Track part sequences too
-        (data[:parts] || []).each do |part|
-          pid = part[:id]
-          if pid.is_a?(String) && (m = pid.match(/\Aprt_(\d+)\z/))
-            n = m[1].to_i
-            @part_seq = n if n > @part_seq
-          end
-        end
-      end
+  it "continues sequence numbering from loaded messages" do
+    with_store do |store, dir|
+      store.append_user(text: "Q1")
+      store.append_user(text: "Q2")
+      store2 = Brute::Store::MessageStore.new(session_id: "test-session-123", dir: dir)
+      store2.append_user(text: "Q3").should == "msg_0003"
     end
   end
 end

data/lib/brute/store/session.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "securerandom"
+
+module Brute
+  module Store
+  # Manages session persistence. Each session is a conversation that can be
+  # saved to disk and resumed later.
+  #
+  # Storage layout (per-session directory):
+  #
+  #   ~/.brute/sessions/{session-id}/
+  #     session.meta.json          # session metadata
+  #     context.json               # serialized conversation history
+  #     msg_0001.json              # structured messages (OpenCode format)
+  #     msg_0002.json
+  #     ...
+  #
+  class Session
+    attr_reader :id, :title, :path
+
+    def initialize(id: nil, dir: nil)
+      @id = id || SecureRandom.uuid
+      @base_dir = dir || File.join(Dir.home, ".brute", "sessions")
+      @session_dir = File.join(@base_dir, @id)
+      @path = File.join(@session_dir, "context.json")
+      @title = nil
+      @metadata = {}
+      FileUtils.mkdir_p(@session_dir)
+    end
+
+    def message_store
+      @message_store ||= MessageStore.new(session_id: @id, dir: @session_dir)
+    end
+
+    # Serialize an array of LLM::Message objects to disk as JSON.
+    def save_messages(messages, title: nil, metadata: {})
+      @title = title if title
+      @metadata.merge!(metadata)
+
+      data = {
+        schema_version: 1,
+        messages: messages.map { |m| { role: m.role.to_s, content: m.content.to_s } },
+      }
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.write(@path, JSON.pretty_generate(data))
+
+      save_meta
+    end
+
+    # List all saved sessions, newest first.
+    def self.list(dir: nil)
+      dir ||= File.join(Dir.home, ".brute", "sessions")
+
+      if File.directory?(dir)
+        sessions = Dir.glob(File.join(dir, "*", "session.meta.json")).filter_map do |meta_path|
+          data = JSON.parse(File.read(meta_path), symbolize_names: true)
+          id = data[:id]
+          next unless id
+          {
+            id: id,
+            title: data[:title],
+            saved_at: data[:saved_at],
+            path: File.join(File.dirname(meta_path), "context.json"),
+          }
+        end
+
+        sessions.sort_by { |s| s[:saved_at] || "" }.reverse
+      else
+        []
+      end
+    end
+
+    def delete
+      FileUtils.rm_rf(@session_dir) if File.directory?(@session_dir)
+    end
+
+    private
+
+      def meta_path
+        File.join(@session_dir, "session.meta.json")
+      end
+
+      def save_meta
+        data = {
+          id: @id,
+          title: @title,
+          saved_at: Time.now.iso8601,
+          metadata: @metadata,
+        }
+        FileUtils.mkdir_p(@session_dir)
+        File.write(meta_path, JSON.pretty_generate(data))
+      end
+
+      def load_meta
+        return unless File.exist?(meta_path)
+
+        data = JSON.parse(File.read(meta_path), symbolize_names: true)
+        @title = data[:title]
+        @metadata = data[:metadata] || {}
+      end
+  end
+  end
+end

data/lib/brute/{snapshot_store.rb → store/snapshot_store.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 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.
@@ -46,4 +47,5 @@ module Brute
       end
     end
   end
+  end
 end

data/lib/brute/{todo_store.rb → store/todo_store.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Brute
+  module Store
   # In-memory todo list storage. The agent uses this to track multi-step tasks.
   # The list is replaced wholesale on each todo_write call.
   module TodoStore
@@ -24,4 +25,5 @@ module Brute
       end
     end
   end
+  end
 end

data/lib/brute/system_prompt.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "brute"
+
 module Brute
   # Deferred system prompt builder.
   #
@@ -105,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,
@@ -164,3 +179,89 @@ module Brute
     end
   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
+
+  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
+end

data/lib/brute/tools/delegate.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "brute"
+
 module Brute
   module Tools
     class Delegate < LLM::Tool
@@ -57,3 +60,59 @@ module Brute
     end
   end
 end
+
+test do
+  require_relative "../../../spec/support/mock_provider"
+  require_relative "../../../spec/support/mock_response"
+
+  FakeMsg = Struct.new(:role, :content) do
+    def assistant?; role == :assistant; 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
+
+  delegate = Brute::Tools::Delegate.new
+
+  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
+
+  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 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
+
+  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 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
+
+  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