brute 0.4.1 → 1.0.0

data/lib/brute/queue/parallel_queue.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Queue
+  # A queue that processes steps concurrently up to a limit.
+  # Workers match concurrency slots.
+  class ParallelQueue < BaseQueue
+    def initialize(concurrency: 4, parent: Async::Task.current)
+      super(concurrency: concurrency, worker_count: concurrency, parent: parent)
+    end
+  end
+  end
+end
+
+test do
+  it "runs steps concurrently" do
+    Sync do
+      concurrent = 0
+      max_concurrent = 0
+
+      steps = 4.times.map do
+        Class.new(Brute::Loop::Step) do
+          define_method(:perform) do |task|
+            concurrent += 1
+            max_concurrent = [max_concurrent, concurrent].max
+            sleep 0.05
+            concurrent -= 1
+          end
+        end.new
+      end
+
+      q = Brute::Queue::ParallelQueue.new(concurrency: 4)
+      steps.each { |s| q << s }
+      q.start
+      q.drain
+      (max_concurrent > 1).should.be.true
+    end
+  end
+
+  it "limits concurrency to the specified amount" do
+    Sync do
+      concurrent = 0
+      max_concurrent = 0
+
+      steps = 8.times.map do
+        Class.new(Brute::Loop::Step) do
+          define_method(:perform) do |task|
+            concurrent += 1
+            max_concurrent = [max_concurrent, concurrent].max
+            sleep 0.05
+            concurrent -= 1
+          end
+        end.new
+      end
+
+      q = Brute::Queue::ParallelQueue.new(concurrency: 2)
+      steps.each { |s| q << s }
+      q.start
+      q.drain
+      (max_concurrent <= 2).should.be.true
+    end
+  end
+end

data/lib/brute/queue/sequential_queue.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Queue
+  # A queue that processes steps one at a time, in order.
+  # One worker, one concurrency slot.
+  class SequentialQueue < BaseQueue
+    def initialize(parent: Async::Task.current)
+      super(concurrency: 1, worker_count: 1, parent: parent)
+    end
+  end
+  end
+end
+
+test do
+  class OrderStep < Brute::Loop::Step
+    def perform(task)
+      @attributes[:log] << @attributes[:value]
+      sleep(@attributes[:delay]) if @attributes[:delay]
+      @attributes[:value]
+    end
+  end
+
+  it "processes steps in order" do
+    Sync do
+      log = []
+      q = Brute::Queue::SequentialQueue.new
+      q << OrderStep.new(log: log, value: "a", delay: 0.01)
+      q << OrderStep.new(log: log, value: "b", delay: 0.01)
+      q << OrderStep.new(log: log, value: "c", delay: 0.01)
+      q.start
+      q.drain
+      log.should == ["a", "b", "c"]
+    end
+  end
+
+  it "runs only one step at a time" do
+    Sync do
+      concurrent = 0
+      max_concurrent = 0
+
+      steps = 3.times.map do
+        Class.new(Brute::Loop::Step) do
+          define_method(:perform) do |task|
+            concurrent += 1
+            max_concurrent = [max_concurrent, concurrent].max
+            sleep 0.02
+            concurrent -= 1
+          end
+        end.new
+      end
+
+      q = Brute::Queue::SequentialQueue.new
+      steps.each { |s| q << s }
+      q.start
+      q.drain
+      max_concurrent.should == 1
+    end
+  end
+end

data/lib/brute/store/message_store.rb

@@ -0,0 +1,362 @@
+# 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.
+  #
+  # Storage layout:
+  #
+  #   ~/.brute/sessions/{session-id}/
+  #     session.meta.json
+  #     msg_0001.json
+  #     msg_0002.json
+  #     ...
+  #
+  # Message format matches OpenCode's MessageV2.WithParts:
+  #
+  #   { info: { id:, sessionID:, role:, time:, ... },
+  #     parts: [{ id:, type:, ... }, ...] }
+  #
+  class MessageStore
+    attr_reader :session_id, :dir
+
+    def initialize(session_id:, dir: nil)
+      @session_id = session_id
+      @dir = dir || File.join(Dir.home, ".brute", "sessions", session_id)
+      @messages = {}   # id => { info:, parts: }
+      @seq = 0
+      @part_seq = 0
+      @mutex = Mutex.new
+      load_existing
+    end
+
+    def append_user(text:, message_id: nil)
+      id = message_id || next_message_id
+      msg = {
+        info: {
+          id: id,
+          sessionID: @session_id,
+          role: "user",
+          time: { created: now_ms },
+        },
+        parts: [
+          { id: next_part_id, sessionID: @session_id, messageID: id,
+            type: "text", text: text },
+        ],
+      }
+      save_message(id, msg)
+      id
+    end
+
+    def append_assistant(message_id: nil, parent_id: nil, model_id: nil, provider_id: nil)
+      id = message_id || next_message_id
+      msg = {
+        info: {
+          id: id,
+          sessionID: @session_id,
+          role: "assistant",
+          parentID: parent_id,
+          time: { created: now_ms },
+          modelID: model_id,
+          providerID: provider_id,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          cost: 0.0,
+        },
+        parts: [],
+      }
+      save_message(id, msg)
+      id
+    end
+
+    def add_text_part(message_id:, text:)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        part = { id: next_part_id, sessionID: @session_id, messageID: message_id,
+                 type: "text", text: text }
+        msg[:parts] << part
+        persist(message_id)
+        part[:id]
+      end
+    end
+
+    def add_tool_part(message_id:, tool:, call_id:, input:)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        part = {
+          id: next_part_id, sessionID: @session_id, messageID: message_id,
+          type: "tool", callID: call_id, tool: tool,
+          state: {
+            status: "running",
+            input: input,
+            time: { start: now_ms },
+          },
+        }
+        msg[:parts] << part
+        persist(message_id)
+        part[:id]
+      end
+    end
+
+    def complete_tool_part(message_id:, call_id:, output:)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        part = msg[:parts].find { |p| p[:type] == "tool" && p[:callID] == call_id }
+        return unless part
+
+        part[:state][:status] = "completed"
+        part[:state][:output] = output
+        part[:state][:time][:end] = now_ms
+        persist(message_id)
+      end
+    end
+
+    def error_tool_part(message_id:, call_id:, error:)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        part = msg[:parts].find { |p| p[:type] == "tool" && p[:callID] == call_id }
+        return unless part
+
+        part[:state][:status] = "error"
+        part[:state][:error] = error.to_s
+        part[:state][:time][:end] = now_ms
+        persist(message_id)
+      end
+    end
+
+    def add_step_finish(message_id:, tokens: nil)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        part = {
+          id: next_part_id, sessionID: @session_id, messageID: message_id,
+          type: "step-finish",
+          reason: "stop",
+          tokens: tokens || { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        }
+        msg[:parts] << part
+        persist(message_id)
+      end
+    end
+
+    # Finalize an assistant message with token counts and completion time.
+    def complete_assistant(message_id:, tokens: nil)
+      @mutex.synchronize do
+        msg = @messages[message_id]
+        return unless msg
+
+        msg[:info][:time][:completed] = now_ms
+        if tokens
+          msg[:info][:tokens] = {
+            input: tokens[:input] || tokens[:total_input] || 0,
+            output: tokens[:output] || tokens[:total_output] || 0,
+            reasoning: tokens[:reasoning] || tokens[:total_reasoning] || 0,
+            cache: tokens[:cache] || { read: 0, write: 0 },
+          }
+        end
+        persist(message_id)
+      end
+    end
+
+    def messages
+      @mutex.synchronize { @messages.values }
+    end
+
+    def message(id)
+      @mutex.synchronize { @messages[id] }
+    end
+
+    def count
+      @mutex.synchronize { @messages.size }
+    end
+
+    private
+
+      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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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