brainiac 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d90a30fad5756179777b90413b87bbd41550783c75c2e9a38f726e1a2e1ef5c
-  data.tar.gz: 32607dc0510acec6449bdb16e8a4acbec358caa94a0d8592d7a6d06e4f73e9a2
+  metadata.gz: 6acdbbb2c88f69d1ca544dca2cb71afb7d4abd3963e4ffb93c1ea90666d4f966
+  data.tar.gz: 738962e302868862b6be89f4cb65f300b0140dc15bfaf1ff258f286492c9c45e
 SHA512:
-  metadata.gz: 1a16401ff3896e546d5411785418228ef5ef2a360dc10fd3633a798723969d90a7d5668d8f8e908856a08bdac35e939519f94bcb79ad6f2f259d0f55dac9c525
-  data.tar.gz: 29947e9e2dacd7007a630a06be63e7e8dbc913f9e677b28ccf92a5dcf4c3659c189291c7d07971b42e06c6c0d08880d266854aa759721d701308a415dfdbb79f
+  metadata.gz: c31b44489df80beab3cb6ed1e5bc7308e1e1926d78793bc73bb9c339ab06a98375ee1b8be1b70e031cdd3c1433c2e9e088976afe96343a08449600868eb206a1
+  data.tar.gz: dabb28067671721b8890aea7a9b5a67d4a3a4bfc434836fcdd41e3cc13c5f7ee05efc6b93acc43dbf09c426b01749d5f68bcb39bfae451a8605ad9e8a4778703

data/README.md

@@ -271,6 +271,15 @@ Set `agent_flag` to `null` to suppress passing the agent name entirely (for CLIs
 
 A provider without `readonly_args` can't be used read-only; the call fails instead of falling back to `default_args`.
 
+`stream_args` and `stream_format` are optional and give you a live agent log for CLIs that otherwise print nothing until they exit. `claude -p` is one: by default it prints only the final answer. `stream_args` is added only to background dispatches that write to a log (never `ask_agent`, which needs plain text). `stream_format` sends the output through a formatter that turns the JSON events into readable lines: assistant text, `▸ Bash: git status` for each tool call, and a closing `--- done · 14 turns · 6m12s · $0.82` line.
+
+```json
+"stream_args": "--output-format stream-json --verbose",
+"stream_format": "claude"
+```
+
+`claude` is the only `stream_format` so far. Lines that aren't JSON pass through unchanged.
+
 Which provider runs is decided in this order: a `[cli:X]` tag, the agent's `cli_provider` in `agents.json`, the project's `cli_provider`, then `default_cli_provider` in `brainiac.json`. With none of those set, brainiac uses the `AGENT_CLI` env var, or kiro-cli.
 
 #### Asking an agent from a plugin

data/lib/brainiac/helpers.rb

@@ -35,7 +35,7 @@ def load_cli_provider(provider_name)
   %w[prompt_flag readonly_args list_models_command resume_flag resume_args resume_id_flag new_session_id_flag
      session_list_command session_id_field session_directory_field session_updated_field
      session_list_path session_dir output_last_message_flag cwd_flag config_override_flag
-     effort_config_key effort_map title_flag heaviness_probe settings_model_cmd].each do |key|
+     effort_config_key effort_map title_flag heaviness_probe settings_model_cmd stream_args stream_format].each do |key|
     next unless raw[key]
     next if raw[key].respond_to?(:empty?) && raw[key].empty?
 
@@ -942,6 +942,7 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
                                   prompt_file: prompt_file, resume: should_resume,
                                   output_file: output_file, chdir: chdir, title: work_item_id,
                                   new_session_id: minted_session_id)
+  append_stream_args(cmd, resolved)
   # Profile env (named bundle, e.g. an alternate kiro-cli account) layers between
   # agent env and the explicit `env:` passed in. An explicitly-requested profile
   # wins over agent env; the default profile is only a fallback. See profiles.rb.
@@ -962,10 +963,11 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
 
   started_at = Time.now
   stdin_redirect = (resolved["prompt_mode"] || "stdin") == "stdin" ? { in: prompt_file } : {}
-  pid = spawn(spawn_env, *cmd, chdir: chdir, **stdin_redirect, out: [log_file, "w"], err: %i[child out])
+  pid, formatter = spawn_agent_process(spawn_env, cmd, resolved,
+                                       chdir: chdir, log_file: log_file, stdin_redirect: stdin_redirect)
 
   spawn_completion_watcher(
-    pid: pid, agent_cli: resolved["agent_cli"], agent_config_name: agent_config_name,
+    pid: pid, formatter: formatter, agent_cli: resolved["agent_cli"], agent_config_name: agent_config_name,
     agent_name: agent_name, log_file: log_file, log_name: log_name,
     prompt_file: prompt_file, chdir: chdir, source: source,
     source_context: source_context, project_config: project_config,
@@ -982,10 +984,42 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   [pid, log_file]
 end
 
+# stream_args (e.g. claude's --output-format stream-json) only apply to run_agent, where
+# output goes to a log. ask_agent shares build_agent_cmd and needs plain text on stdout.
+def append_stream_args(cmd, resolved)
+  cmd.concat(resolved["stream_args"].split) if resolved["stream_args"]
+end
+
+STREAM_FORMATTER_PATH = File.expand_path("stream_formatter.rb", __dir__)
+# How long to wait for the formatter to drain after the agent exits. It normally sees EOF
+# right away, but a background process the agent left running can hold the pipe open.
+STREAM_FORMATTER_DRAIN_SECONDS = 10
+
+# Start the agent with its output going to log_file. When the provider sets stream_format,
+# the agent writes to a pipe instead and a separate formatter process turns the JSONL into
+# readable lines in the log. Both are plain child processes, so they outlive a server restart
+# the same way the agent alone does. Returns [agent_pid, formatter_waiter_or_nil].
+def spawn_agent_process(spawn_env, cmd, resolved, chdir:, log_file:, stdin_redirect:)
+  return [spawn(spawn_env, *cmd, chdir: chdir, **stdin_redirect, out: [log_file, "w"], err: %i[child out]), nil] unless resolved["stream_format"]
+
+  reader, writer = IO.pipe
+  formatter_pid = spawn(RbConfig.ruby, STREAM_FORMATTER_PATH, resolved["stream_format"],
+                        in: reader, out: [log_file, "w"], err: %i[child out])
+  pid = spawn(spawn_env, *cmd, chdir: chdir, **stdin_redirect, out: writer, err: writer)
+  [pid, Process.detach(formatter_pid)]
+ensure
+  reader&.close
+  writer&.close
+end
+
 # Spawn a background thread that waits for the agent process to finish and runs completion handling.
 def spawn_completion_watcher(**ctx)
+  formatter = ctx.delete(:formatter)
   thread = Thread.new do
     Process.wait(ctx[:pid])
+    # Let the formatter finish writing the log before completion reads it. It runs in its
+    # own waiter thread, so $CHILD_STATUS here still belongs to the agent.
+    formatter&.join(STREAM_FORMATTER_DRAIN_SECONDS)
     handle_agent_completion(**ctx)
   end
   # Without this, an unrescued exception anywhere in handle_agent_completion silently

data/lib/brainiac/stream_formatter.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# Turns a CLI's JSONL event stream into a readable agent log.
+#
+# run_agent spawns this as its own process between the agent and the log file when the
+# provider sets `stream_format` (see run_agent / spawn_agent_with_formatter). It runs
+# outside the server so a brainiac restart can't break the pipe and kill the agent.
+#
+#   claude ... --output-format stream-json --verbose | ruby stream_formatter.rb claude > log
+#
+# Lines that aren't JSON (mise noise, stderr, crashes) pass through unchanged, so the
+# crash snippet still shows whatever went wrong. Summary lines start with "---" so
+# detect_no_output_reason treats them as boilerplate, like it does kiro's banners.
+
+require "json"
+
+module StreamFormatter
+  MAX_SUMMARY = 160
+
+  module_function
+
+  # Format a single line of stream output. Returns an array of log lines (maybe empty).
+  def format_line(format, line)
+    event = JSON.parse(line)
+    return [line.chomp] unless event.is_a?(Hash)
+
+    case format
+    when "claude" then format_claude(event)
+    else [line.chomp]
+    end
+  rescue JSON::ParserError
+    [line.chomp]
+  end
+
+  def format_claude(event)
+    case event["type"]
+    when "system" then claude_system(event)
+    when "assistant" then claude_assistant(event)
+    when "user" then claude_tool_errors(event)
+    when "result" then claude_result(event)
+    else []
+    end
+  end
+
+  def claude_system(event)
+    return [] unless event["subtype"] == "init"
+
+    ["--- claude #{event["claude_code_version"]} · #{event["model"]} · session #{event["session_id"]}"]
+  end
+
+  # Assistant text prints as-is; each tool call becomes a "▸ Tool: summary" line.
+  # Events from a subagent carry parent_tool_use_id and are indented under it.
+  def claude_assistant(event)
+    indent = event["parent_tool_use_id"] ? "  " : ""
+    Array(event.dig("message", "content")).flat_map do |block|
+      case block["type"]
+      when "text"
+        text = block["text"].to_s.strip
+        text.empty? ? [] : text.lines.map { |l| "#{indent}#{l.chomp}" } + [""]
+      when "tool_use"
+        summary = tool_summary(block["name"], block["input"] || {})
+        ["#{indent}▸ #{block["name"]}#{": #{summary}" unless summary.empty?}"]
+      else []
+      end
+    end
+  end
+
+  # Successful tool results are noise in a progress log; failed ones are worth a line.
+  def claude_tool_errors(event)
+    indent = event["parent_tool_use_id"] ? "    " : "  "
+    Array(event.dig("message", "content")).filter_map do |block|
+      next unless block.is_a?(Hash) && block["type"] == "tool_result" && block["is_error"]
+
+      "#{indent}✗ #{truncate(first_line(result_text(block["content"])))}"
+    end
+  end
+
+  def claude_result(event)
+    parts = [event["subtype"] == "success" ? "done" : event["subtype"]]
+    parts << "#{event["num_turns"]} turns" if event["num_turns"]
+    parts << format_duration(event["duration_ms"]) if event["duration_ms"]
+    parts << format("$%.2f", event["total_cost_usd"]) if event["total_cost_usd"]
+    lines = ["--- #{parts.join(" · ")}"]
+    # Errors (usage limits, API failures) only show up here, so print the message where
+    # detect_no_output_reason can match it.
+    lines.unshift("✗ #{event["result"]}") if event["is_error"] && event["result"]
+    lines
+  end
+
+  def tool_summary(name, input)
+    value = case name
+            when "Bash" then input["command"]
+            when "Read", "Edit", "Write", "MultiEdit" then input["file_path"]
+            when "NotebookEdit" then input["notebook_path"]
+            when "Grep", "Glob" then [input["pattern"], input["path"]].compact.join(" in ")
+            when "Agent", "Task" then input["description"]
+            when "WebFetch" then input["url"]
+            when "WebSearch" then input["query"]
+            when "Skill" then input["skill"]
+            else input.values.find { |v| v.is_a?(String) }
+            end
+    truncate(first_line(value.to_s))
+  end
+
+  def result_text(content)
+    return content.to_s unless content.is_a?(Array)
+
+    content.filter_map { |c| c["text"] if c.is_a?(Hash) }.join("\n")
+  end
+
+  def first_line(text)
+    text.strip.lines.first.to_s.chomp
+  end
+
+  def truncate(text)
+    text.length > MAX_SUMMARY ? "#{text[0, MAX_SUMMARY - 1]}…" : text
+  end
+
+  def format_duration(millis)
+    secs = (millis / 1000.0).round
+    secs < 60 ? "#{secs}s" : "#{secs / 60}m#{format("%02d", secs % 60)}s"
+  end
+
+  def run(format, input: $stdin, output: $stdout)
+    output.sync = true
+    input.each_line do |line|
+      format_line(format, line).each { |l| output.puts(l) }
+    end
+  end
+end
+
+StreamFormatter.run(ARGV.fetch(0, "claude")) if $PROGRAM_NAME == __FILE__

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/receiver.rb

@@ -22,6 +22,7 @@ require_relative "lib/brainiac/sessions"
 require_relative "lib/brainiac/session_history"
 require_relative "lib/brainiac/prompts"
 require_relative "lib/brainiac/helpers"
+require_relative "lib/brainiac/ask"
 require_relative "lib/brainiac/notifications"
 require_relative "lib/brainiac/cron"
 require_relative "lib/brainiac/restart"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andy Davis
@@ -146,6 +146,7 @@ files:
 - lib/brainiac/session_history.rb
 - lib/brainiac/sessions.rb
 - lib/brainiac/skills.rb
+- lib/brainiac/stream_formatter.rb
 - lib/brainiac/users.rb
 - lib/brainiac/version.rb
 - monitor/daemon.rb