brute_rack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b7e3f20b9ac6c79ca75305edcd49c5e73f407a083a26e00dc02065413aa0d96
+  data.tar.gz: f3a6c8efd975fe580c3608d5568930d250d8f983cbf541a20eefc8dfa895c5ec
+SHA512:
+  metadata.gz: f286b4d40dce441de9d2055509e72606a601bbd8a34355bfeb6c2038ae67271a942cdaed4f5747e75d03f660a2795a0f9bfa1d5fc765f42255ed6ef038be93a8
+  data.tar.gz: d47fcedfff3ce7845ae555586ba4b35bda21bc5833698fff0af9f34dba176d8fecaeee851c7c4eea519f27122d0fe0352dbf929fd8eff33152aaa8c6d925fdcb

data/exe/brute-client

@@ -0,0 +1,290 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# CLI client for the Brute HTTP server.
+#
+# Usage:
+#   brute-client health
+#   brute-client prompt "Fix the failing tests"
+#   brute-client prompt --session abc123 "Continue working"
+#   brute-client stream "Refactor the auth module"
+#   brute-client sessions
+#   brute-client sessions create --title "Bug fix"
+#   brute-client sessions delete <id>
+#   brute-client files list .
+#   brute-client files read app.rb
+#   brute-client files search "def initialize"
+#   brute-client files status
+#   brute-client tools
+#   brute-client config
+#   brute-client vcs
+#   brute-client shell "ls -la"
+
+require "net/http"
+require "json"
+require "uri"
+require "optparse"
+
+class BruteClient
+  def initialize(base_url)
+    @base = URI.parse(base_url)
+  end
+
+  def get(path, query: nil)
+    uri = URI.join(@base, path)
+    uri.query = URI.encode_www_form(query) if query
+    Net::HTTP.get_response(uri).then { |r| handle(r) }
+  end
+
+  def post(path, body: {})
+    uri = URI.join(@base, path)
+    Net::HTTP.post(uri, JSON.generate(body), "Content-Type" => "application/json").then { |r| handle(r) }
+  end
+
+  def delete(path)
+    uri = URI.join(@base, path)
+    req = Net::HTTP::Delete.new(uri)
+    Net::HTTP.start(uri.host, uri.port) { |http| http.request(req) }.then { |r| handle(r) }
+  end
+
+  def stream(path, body: {})
+    uri = URI.join(@base, path)
+    req = Net::HTTP::Post.new(uri)
+    req["Content-Type"] = "application/json"
+    req["Accept"] = "text/event-stream"
+    req.body = JSON.generate(body)
+
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request(req) do |response|
+        response.read_body do |chunk|
+          chunk.lines.each do |line|
+            case line
+            when /\Aevent: (.+)/
+              @current_event = $1.strip
+            when /\Adata: (.+)/
+              handle_sse_event(@current_event, $1.strip)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def handle(response)
+    case response.code.to_i
+    when 200..299
+      begin
+        JSON.parse(response.body).then { |data| pp data }
+      rescue JSON::ParserError
+        puts response.body
+      end
+    when 204
+      puts "(no content)"
+    else
+      $stderr.puts "Error #{response.code}: #{response.body}"
+      exit 1
+    end
+  end
+
+  def handle_sse_event(type, data)
+    parsed = JSON.parse(data) rescue { "raw" => data }
+    case type
+    when "content"
+      print parsed["text"]
+    when "tool_call"
+      $stderr.puts "\n--- [#{parsed["name"]}] ---"
+    when "tool_result"
+      $stderr.puts "  [#{parsed["success"] ? "ok" : "FAILED"}]"
+    when "done"
+      puts
+      $stderr.puts "Tools: #{parsed["tools_called"]&.join(", ")}" if parsed["tools_called"]&.any?
+    when "error"
+      $stderr.puts "Error: #{parsed["message"]}"
+    when "server.connected"
+      $stderr.puts "Connected to brute-server #{parsed["version"]}"
+    else
+      $stderr.puts "[#{type}] #{data}"
+    end
+  end
+end
+
+# --- CLI ---
+
+base_url = ENV["BRUTE_SERVER"] || "http://127.0.0.1:9292"
+client = BruteClient.new(base_url)
+
+command = ARGV.shift
+
+case command
+when "health"
+  client.get("/global/health")
+
+when "prompt"
+  session_id = nil
+  parser = OptionParser.new do |opts|
+    opts.on("-s", "--session ID") { |id| session_id = id }
+  end
+  parser.order!(ARGV)
+  message = ARGV.join(" ")
+  abort "Usage: brute-client prompt \"your message\"" if message.empty?
+
+  session_id ||= SecureRandom.uuid
+  client.post("/session/#{session_id}/message", body: {
+    parts: [{ type: "text", text: message }],
+  })
+
+when "stream"
+  message = ARGV.join(" ")
+  abort "Usage: brute-client stream \"your message\"" if message.empty?
+
+  session_id = SecureRandom.uuid
+  client.post("/session", body: { title: message[0..50] })
+  # Use prompt_async + event stream
+  # For now, use blocking message which returns the full response
+  client.post("/session/#{session_id}/message", body: {
+    parts: [{ type: "text", text: message }],
+  })
+
+when "sessions"
+  sub = ARGV.shift
+  case sub
+  when "create"
+    title = nil
+    OptionParser.new { |o| o.on("-t", "--title T") { |t| title = t } }.order!(ARGV)
+    client.post("/session", body: { title: title })
+  when "delete"
+    id = ARGV.shift
+    abort "Usage: brute-client sessions delete <id>" unless id
+    client.delete("/session/#{id}")
+  when "status"
+    client.get("/session/status")
+  when nil
+    client.get("/session")
+  else
+    # Treat as session ID — get details
+    client.get("/session/#{sub}")
+  end
+
+when "messages"
+  id = ARGV.shift
+  abort "Usage: brute-client messages <session-id>" unless id
+  msg_id = ARGV.shift
+  if msg_id
+    client.get("/session/#{id}/message/#{msg_id}")
+  else
+    client.get("/session/#{id}/message")
+  end
+
+when "files"
+  sub = ARGV.shift
+  case sub
+  when "list"
+    path = ARGV.shift || "."
+    client.get("/file", query: { path: path })
+  when "read"
+    path = ARGV.shift
+    abort "Usage: brute-client files read <path>" unless path
+    client.get("/file/content", query: { path: path })
+  when "search"
+    pattern = ARGV.join(" ")
+    abort "Usage: brute-client files search <pattern>" if pattern.empty?
+    client.get("/find", query: { pattern: pattern })
+  when "find"
+    query = ARGV.join(" ")
+    abort "Usage: brute-client files find <query>" if query.empty?
+    client.get("/find/file", query: { query: query })
+  when "status"
+    client.get("/file/status")
+  else
+    abort "Usage: brute-client files {list|read|search|find|status}"
+  end
+
+when "tools"
+  sub = ARGV.shift
+  case sub
+  when "ids", nil
+    client.get("/experimental/tool/ids")
+  when "list"
+    client.get("/experimental/tool")
+  else
+    abort "Usage: brute-client tools {ids|list}"
+  end
+
+when "config"
+  sub = ARGV.shift
+  case sub
+  when "providers"
+    client.get("/config/providers")
+  when nil
+    client.get("/config")
+  end
+
+when "provider"
+  client.get("/provider")
+
+when "vcs"
+  client.get("/vcs")
+
+when "path"
+  client.get("/path")
+
+when "shell"
+  command_str = ARGV.join(" ")
+  abort "Usage: brute-client shell \"command\"" if command_str.empty?
+  session_id = SecureRandom.uuid
+  client.post("/session/#{session_id}/shell", body: { command: command_str })
+
+when "todo"
+  id = ARGV.shift
+  abort "Usage: brute-client todo <session-id>" unless id
+  client.get("/session/#{id}/todo")
+
+when "abort"
+  id = ARGV.shift
+  abort "Usage: brute-client abort <session-id>" unless id
+  client.post("/session/#{id}/abort")
+
+when "log"
+  message = ARGV.join(" ")
+  abort "Usage: brute-client log \"message\"" if message.empty?
+  client.post("/log", body: { service: "cli", level: "info", message: message })
+
+when nil, "help", "--help", "-h"
+  puts <<~HELP
+    Usage: brute-client <command> [args]
+
+    Commands:
+      health                          Server health check
+      prompt [-s session] "message"   Send a prompt (blocking)
+      stream "message"                Send a prompt (streaming)
+      sessions                        List sessions
+      sessions create [-t title]      Create a session
+      sessions delete <id>            Delete a session
+      sessions status                 Session statuses
+      messages <session-id> [msg-id]  List/get messages
+      files list [path]               List directory
+      files read <path>               Read file content
+      files search <pattern>          Search file contents
+      files find <query>              Find files by name
+      files status                    Git file status
+      tools [ids|list]                List available tools
+      config [providers]              Show configuration
+      provider                        List providers
+      vcs                             Git info
+      path                            Current directory
+      shell "command"                 Execute shell command
+      todo <session-id>               Session todo list
+      abort <session-id>              Abort running session
+      log "message"                   Write server log entry
+
+    Environment:
+      BRUTE_SERVER   Server URL (default: http://127.0.0.1:9292)
+  HELP
+
+else
+  $stderr.puts "Unknown command: #{command}"
+  $stderr.puts "Run 'brute-client help' for usage."
+  exit 1
+end

data/exe/brute-server

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Start the Brute HTTP server.
+#
+#   brute-server                     # Run ./service.rb in the current directory
+#   brute-server /path/to/service.rb # Run a specific service config
+#
+# Requires async-service and falcon.
+
+config = ARGV.shift || File.join(Dir.pwd, "service.rb")
+
+abort "brute-server: #{config} not found" unless File.exist?(config)
+
+$stderr.puts "brute-server: #{config}"
+exec("async-service", config, *ARGV)

data/exe/brute-server-demo

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run one of the bundled example services.
+#
+#   brute-server-demo                # Run the default example
+#   brute-server-demo default        # Same as above
+#   brute-server-demo restricted     # Read-only research agent
+#   brute-server-demo multi-agent    # Two agents on different ports
+
+EXAMPLES_DIR = File.expand_path("../examples", __dir__)
+AVAILABLE = Dir.children(EXAMPLES_DIR)
+               .select { |d| File.exist?(File.join(EXAMPLES_DIR, d, "service.rb")) }
+               .sort
+
+name = ARGV.shift || "default"
+
+if %w[-h --help help].include?(name)
+  $stderr.puts "Usage: brute-server-demo [example]"
+  $stderr.puts
+  $stderr.puts "Available examples:"
+  AVAILABLE.each { |e| $stderr.puts "  #{e}" }
+  exit
+end
+
+service_rb = File.join(EXAMPLES_DIR, name, "service.rb")
+
+unless File.exist?(service_rb)
+  $stderr.puts "Unknown example: #{name}"
+  $stderr.puts "Available: #{AVAILABLE.join(", ")}"
+  exit 1
+end
+
+brute_server = File.expand_path("brute-server", __dir__)
+exec(brute_server, service_rb, *ARGV)

data/lib/brute_rack/app.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module BruteRack
+  # Rack application implementing the OpenCode-compatible server API.
+  # Routes requests by method + path to endpoint modules.
+  #
+  #   require "brute_rack"
+  #   BruteRack::App.new
+  #
+  class App
+    def self.not_found
+      [404, {"content-type" => "application/json"}, ['{"error":"not found"}']]
+    end
+
+    def self.method_not_allowed
+      [405, {"content-type" => "application/json"}, ['{"error":"method not allowed"}']]
+    end
+
+    def initialize(cwd: Dir.pwd, agent_options: {})
+      @cwd = cwd
+      @logger = Logger.new($stderr, level: Logger::INFO)
+      @event_bus = EventBus.new
+      @registry = SessionRegistry.new(event_bus: @event_bus, cwd: cwd, agent_options: agent_options)
+    end
+
+    def call(env)
+      method = env["REQUEST_METHOD"]
+      path   = env["PATH_INFO"]
+
+      case method
+      when "GET"    then route_get(path, env)
+      when "POST"   then route_post(path, env)
+      when "PATCH"  then route_patch(path, env)
+      when "DELETE" then route_delete(path, env)
+      else self.class.method_not_allowed
+      end
+    end
+
+    private
+
+    def ctx
+      { cwd: @cwd, event_bus: @event_bus, registry: @registry, logger: @logger }
+    end
+
+    # ----------------------------------------------------------------
+    # GET
+    # ----------------------------------------------------------------
+    def route_get(path, env)
+      case path
+      # Global
+      when "/global/health"             then Endpoints::Global.health(env, **ctx)
+      when "/global/event"              then Endpoints::Global.event(env, **ctx)
+      when "/event"                     then Endpoints::Global.event(env, **ctx)
+      # Sessions
+      when "/session"                   then Endpoints::Sessions.list(env, **ctx)
+      when "/session/status"            then Endpoints::Sessions.status(env, **ctx)
+      when %r{\A/session/([^/]+)/message/(.+)\z}
+        Endpoints::Messages.get_message(env, id: $1, message_id: $2, **ctx)
+      when %r{\A/session/([^/]+)/message\z}
+        Endpoints::Messages.list(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/todo\z}
+        Endpoints::Sessions.todo(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)\z}
+        Endpoints::Sessions.get(env, id: $1, **ctx)
+      # Files
+      when "/find"                      then Endpoints::Files.find(env, **ctx)
+      when "/find/file"                 then Endpoints::Files.find_file(env, **ctx)
+      when "/file/content"              then Endpoints::Files.content(env, **ctx)
+      when "/file/status"               then Endpoints::Files.status(env, **ctx)
+      when "/file"                      then Endpoints::Files.list(env, **ctx)
+      # Tools
+      when "/experimental/tool/ids"     then Endpoints::Tools.ids(env, **ctx)
+      when "/experimental/tool"         then Endpoints::Tools.list(env, **ctx)
+      # Config & Provider
+      when "/config/providers"          then Endpoints::Config.providers(env, **ctx)
+      when "/config"                    then Endpoints::Config.get(env, **ctx)
+      when "/provider"                  then Endpoints::Provider.list(env, **ctx)
+      # Path & VCS
+      when "/path"                      then Endpoints::PathVcs.path(env, **ctx)
+      when "/vcs"                       then Endpoints::PathVcs.vcs(env, **ctx)
+      else self.class.not_found
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # POST
+    # ----------------------------------------------------------------
+    def route_post(path, env)
+      case path
+      # Sessions
+      when "/session"
+        Endpoints::Sessions.create(env, **ctx)
+      when %r{\A/session/([^/]+)/message\z}
+        Endpoints::Messages.send_message(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/prompt_async\z}
+        Endpoints::Messages.prompt_async(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/shell\z}
+        Endpoints::Messages.shell(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/abort\z}
+        Endpoints::Sessions.abort(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/fork\z}
+        Endpoints::Sessions.fork(env, id: $1, **ctx)
+      when %r{\A/session/([^/]+)/summarize\z}
+        Endpoints::Sessions.summarize(env, id: $1, **ctx)
+      # Flow (brute-specific)
+      when "/flow"
+        Endpoints::Flow.call(env, **ctx)
+      # Logging
+      when "/log"
+        Endpoints::Logging.create(env, **ctx)
+      else self.class.not_found
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # PATCH
+    # ----------------------------------------------------------------
+    def route_patch(path, env)
+      case path
+      when %r{\A/session/([^/]+)\z}
+        Endpoints::Sessions.update(env, id: $1, **ctx)
+      else self.class.not_found
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # DELETE
+    # ----------------------------------------------------------------
+    def route_delete(path, env)
+      case path
+      when %r{\A/session/([^/]+)\z}
+        Endpoints::Sessions.delete(env, id: $1, **ctx)
+      else self.class.not_found
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # GET /config            → agent configuration
+    # GET /config/providers  → available providers and models
+    module Config
+      PROVIDER_MAP = {
+        "ANTHROPIC_API_KEY" => { id: "anthropic", name: "Anthropic", models: ["claude-sonnet-4-20250514", "claude-haiku-4-20250414"] },
+        "OPENAI_API_KEY"    => { id: "openai",    name: "OpenAI",    models: ["gpt-4o", "gpt-4o-mini", "o3-mini"] },
+        "GOOGLE_API_KEY"    => { id: "google",    name: "Google",    models: ["gemini-2.0-flash", "gemini-2.5-pro"] },
+      }.freeze
+
+      def self.get(_env, cwd:, **)
+        {
+          version: Brute::VERSION,
+          cwd: cwd,
+          tools: LLM::Function.registry.map(&:name),
+          tool_count: LLM::Function.registry.size,
+          providers: available_providers.map { |p| p[:id] },
+        }.then { |config| [200, HEADERS_JSON, [JSON.generate(config)]] }
+      end
+
+      def self.providers(_env, **)
+        providers = available_providers
+        defaults = providers.each_with_object({}) { |p, h| h[p[:id]] = p[:models].first }
+        [200, HEADERS_JSON, [JSON.generate(providers: providers, default: defaults)]]
+      end
+
+      def self.available_providers
+        PROVIDER_MAP.filter_map do |env_key, info|
+          info if ENV[env_key]
+        end
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/files.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module BruteRack
+  module Endpoints
+    # GET /find?pattern=<pat>       → search file contents (ripgrep)
+    # GET /find/file?query=<q>      → find files by name
+    # GET /file?path=<path>         → list directory
+    # GET /file/content?path=<p>    → read file content
+    # GET /file/status              → git status
+    module Files
+      def self.find(env, cwd:, **)
+        params = parse_query(env)
+        pattern = params["pattern"]
+        return [400, HEADERS_JSON, [JSON.generate(error: "pattern required")]] unless pattern
+
+        Brute::Tools::FSSearch.new.call(pattern: pattern, path: cwd).then do |result|
+          matches = result[:results].to_s.lines.filter_map do |line|
+            if line =~ /\A(.+?):(\d+):(.*)/
+              { path: $1, line_number: $2.to_i, lines: $3.strip }
+            end
+          end
+          [200, HEADERS_JSON, [JSON.generate(matches)]]
+        end
+      end
+
+      def self.find_file(env, cwd:, **)
+        params = parse_query(env)
+        query = params["query"]
+        return [400, HEADERS_JSON, [JSON.generate(error: "query required")]] unless query
+
+        limit = (params["limit"] || 50).to_i.clamp(1, 200)
+        type_filter = params["type"] # "file" or "directory"
+
+        cmd = ["find", cwd, "-maxdepth", "8", "-iname", "*#{query}*"]
+        cmd += ["-type", "f"] if type_filter == "file"
+        cmd += ["-type", "d"] if type_filter == "directory"
+
+        Open3.capture3(*cmd).then do |stdout, _, _|
+          paths = stdout.lines.map(&:strip).reject(&:empty?).first(limit)
+          [200, HEADERS_JSON, [JSON.generate(paths)]]
+        end
+      end
+
+      def self.list(env, cwd:, **)
+        params = parse_query(env)
+        path = File.expand_path(params["path"] || ".", cwd)
+
+        return [404, HEADERS_JSON, [JSON.generate(error: "not found")]] unless File.directory?(path)
+
+        Dir.entries(path).reject { |f| f.start_with?(".") }.sort.map do |name|
+          full = File.join(path, name)
+          {
+            name: name,
+            path: full,
+            type: File.directory?(full) ? "directory" : "file",
+            size: File.file?(full) ? File.size(full) : nil,
+          }
+        end.then do |nodes|
+          [200, HEADERS_JSON, [JSON.generate(nodes)]]
+        end
+      end
+
+      def self.content(env, cwd:, **)
+        params = parse_query(env)
+        path = params["path"]
+        return [400, HEADERS_JSON, [JSON.generate(error: "path required")]] unless path
+
+        full = File.expand_path(path, cwd)
+        return [404, HEADERS_JSON, [JSON.generate(error: "not found")]] unless File.exist?(full)
+        return [400, HEADERS_JSON, [JSON.generate(error: "not a file")]] unless File.file?(full)
+
+        {
+          path: full,
+          content: File.read(full, encoding: "UTF-8"),
+          size: File.size(full),
+          lines: File.readlines(full).size,
+        }.then do |result|
+          [200, HEADERS_JSON, [JSON.generate(result)]]
+        end
+      rescue Encoding::InvalidByteSequenceError
+        [400, HEADERS_JSON, [JSON.generate(error: "binary file")]]
+      end
+
+      def self.status(_env, cwd:, **)
+        Open3.capture3("git", "status", "--porcelain", chdir: cwd).then do |stdout, _, st|
+          if st.success?
+            files = stdout.lines.map { |l|
+              { status: l[0..1].strip, path: l[3..].strip }
+            }
+            [200, HEADERS_JSON, [JSON.generate(files)]]
+          else
+            [200, HEADERS_JSON, [JSON.generate([])]]
+          end
+        end
+      end
+
+      def self.parse_query(env)
+        Rack::Utils.parse_query(env["QUERY_STRING"] || "")
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/flow.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # POST /flow — run a BPMN multi-agent flow.
+    #
+    # Request:  { "message": "...", "cwd": "..." }
+    # Response: { "result": {...} }
+    #
+    # Requires the brute_flow gem to be installed.
+    #
+    module Flow
+      def self.call(env, cwd:)
+        require "brute_flow"
+
+        JSON.parse(env["rack.input"].read).then do |body|
+          Brute.flow(cwd: body["cwd"] || cwd, variables: { user_message: body["message"] }) do
+            service :router, type: "Brute::Flow::Services::RouterService"
+            exclusive_gateway :mode, default: :simple_path do
+              branch :fibre_path, condition: '=agent_mode = "fibre"' do
+                parallel do
+                  service :tools,  type: "Brute::Flow::Services::ToolSuggestService"
+                  service :memory, type: "Brute::Flow::Services::MemoryRecallService"
+                end
+                service :agent, type: "Brute::Flow::Services::AgentService"
+              end
+              branch :simple_path do
+                service :agent, type: "Brute::Flow::Services::AgentService"
+              end
+            end
+          end.then do |runner|
+            runner.run.then do |result|
+              [200, {"content-type" => "application/json"}, [JSON.generate(result: result)]]
+            end
+          end
+        end
+      rescue LoadError
+        [501, {"content-type" => "application/json"},
+         [JSON.generate(error: "brute_flow gem not installed")]]
+      rescue => e
+        [500, {"content-type" => "application/json"},
+         [JSON.generate(error: e.message)]]
+      end
+    end
+  end
+end