brute 1.0.0 → 2.0.0

data/lib/brute/queue/base_queue.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "brute"
-
-require "async"
-require "async/queue"
-require "async/barrier"
-require "async/semaphore"
-
-module Brute
-  module Queue
-  # A queue that dequeues Step objects and runs them, honoring cancellation.
-  #
-  # Composes four async primitives:
-  #   - An inbox (Async::Queue) that holds pending steps
-  #   - A barrier (Async::Barrier) that tracks every task the queue spawns
-  #   - A semaphore (Async::Semaphore) parented to the barrier, limiting concurrency
-  #   - Workers — long-lived tasks that dequeue from the inbox and run steps
-  #
-  # The barrier-semaphore composition via parent: means every task the
-  # semaphore spawns is also tracked by the barrier. One call site
-  # (semaphore.async), two guarantees (scoped lifetime + bounded concurrency).
-  #
-  class BaseQueue
-    attr_reader :steps
-
-    def initialize(concurrency:, worker_count:, parent: Async::Task.current)
-      @steps        = []
-      @inbox        = Async::Queue.new
-      @barrier      = Async::Barrier.new(parent: parent)
-      @semaphore    = Async::Semaphore.new(concurrency, parent: @barrier)
-      @worker_count = worker_count
-      @started      = false
-    end
-
-    def <<(step)
-      @steps << step
-      @inbox.push(step)
-      self
-    end
-
-    def first = @steps.first
-    def last  = @steps.last
-
-    def start
-      return self if @started
-      @started = true
-
-      @worker_count.times do
-        @barrier.async do
-          while (step = @inbox.dequeue)
-            @semaphore.async do |task|
-              step.call(task)
-            end
-          end
-        end
-      end
-      self
-    end
-
-    # Graceful: stop accepting, wait for running work to finish.
-    def drain
-      @inbox.close
-      @barrier.wait
-    end
-
-    # Hard: close inbox, cancel pending steps, cancel running work.
-    def cancel
-      @inbox.close
-      @steps.each do |step|
-        step.cancel if step.state == :pending
-      end
-      @barrier.cancel
-    end
-  end
-  end
-end
-
-test do
-  class CountStep < Brute::Loop::Step
-    def perform(task)
-      @attributes[:counter] << @attributes[:value]
-      @attributes[:value]
-    end
-  end
-
-  class SleepStep < Brute::Loop::Step
-    def perform(task)
-      sleep(@attributes[:duration])
-      "slept"
-    end
-  end
-
-  # -- enqueue --
-
-  it "appends steps to the steps list" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      q << CountStep.new(counter: [], value: 1)
-      q.steps.size.should == 1
-    end
-  end
-
-  it "returns self from <<" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      (q << CountStep.new(counter: [], value: 1)).should.be.identical_to q
-    end
-  end
-
-  # -- first / last --
-
-  it "returns the first step" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      s1 = CountStep.new(counter: [], value: 1)
-      s2 = CountStep.new(counter: [], value: 2)
-      q << s1 << s2
-      q.first.should.be.identical_to s1
-    end
-  end
-
-  it "returns the last step" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      s1 = CountStep.new(counter: [], value: 1)
-      s2 = CountStep.new(counter: [], value: 2)
-      q << s1 << s2
-      q.last.should.be.identical_to s2
-    end
-  end
-
-  # -- start + drain --
-
-  it "runs steps to completion on drain" do
-    Sync do
-      results = []
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      q << CountStep.new(counter: results, value: "a")
-      q << CountStep.new(counter: results, value: "b")
-      q.start
-      q.drain
-      results.should == ["a", "b"]
-    end
-  end
-
-  it "completes all steps" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      q << CountStep.new(counter: [], value: 1)
-      q << CountStep.new(counter: [], value: 2)
-      q.start
-      q.drain
-      q.steps.all? { |s| s.state == :completed }.should.be.true
-    end
-  end
-
-  it "captures results on each step" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      q << CountStep.new(counter: [], value: 42)
-      q.start
-      q.drain
-      q.first.result.should == 42
-    end
-  end
-
-  it "is idempotent on start" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      q << CountStep.new(counter: [], value: 1)
-      q.start
-      q.start # should not double-spawn workers
-      q.drain
-      q.steps.size.should == 1
-    end
-  end
-
-  # -- cancel --
-
-  it "marks pending steps as cancelled" do
-    Sync do
-      q = Brute::Queue::BaseQueue.new(concurrency: 1, worker_count: 1)
-      s1 = SleepStep.new(duration: 10)
-      s2 = SleepStep.new(duration: 10)
-      s3 = SleepStep.new(duration: 10)
-      q << s1 << s2 << s3
-      q.start
-      sleep 0.01 # let worker pick up s1
-      q.cancel
-      # s2 and s3 should be cancelled (they were pending)
-      [s2, s3].all? { |s| s.state == :cancelled }.should.be.true
-    end
-  end
-
-  # -- concurrent execution --
-
-  it "runs multiple steps concurrently" do
-    Sync do
-      started = []
-      done = []
-
-      steps = 3.times.map do |i|
-        Class.new(Brute::Loop::Step) do
-          define_method(:perform) do |task|
-            started << i
-            sleep 0.05
-            done << i
-            i
-          end
-        end.new
-      end
-
-      q = Brute::Queue::BaseQueue.new(concurrency: 3, worker_count: 3)
-      steps.each { |s| q << s }
-      q.start
-      q.drain
-      done.size.should == 3
-    end
-  end
-end

data/lib/brute/queue/parallel_queue.rb

@@ -1,66 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

@@ -1,362 +0,0 @@
-# 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