brainiac 0.0.27 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 889b0c7491371dd4deb7dc5a173eb5c45045cf9d85a9bf1b5cfcf75bb233d407
-  data.tar.gz: c5532f51f711e5b5839fd3c9cbfe3e297e8ae00849a44b9b82331d13d5d318f0
+  metadata.gz: 37f135fffb0c94919fa376fee96e12053af77062f93dadc520cce7285ee86e78
+  data.tar.gz: 553b10319590bde4fee8f89cf227059fec83d750d6ad7188d56aa5243a6cf169
 SHA512:
-  metadata.gz: 81735abd0d5d4dc9e9aeccaf3ae80e7c51f3ca529f759750e0dc8ad4f3f15a3bee54ea3169f96e9a6e3a7b378d8395940e9b5af10bd92e8117d0fc49a602d855
-  data.tar.gz: 71bfdf3580bbe77aa873be4d7ef211b42f9f19979efce7a76cdcbfdeb30c914bdf9dae48b32d571bf28ad9871f53c1fd92946f025e36d7d9aa2a4e2b38ad4df5
+  metadata.gz: e04d26de1e9010e175b69032358e400223af29ffabde834e48b206d6cff58340fe1082262b36843fe6995aff752df2ed053793a78f416cc47d1dd4b47b881a99
+  data.tar.gz: fe32e3768064d1728a2b28d40aef900c1afb454d04e192b67a9e4f631bf117a147ebef547898709ead380b286336dee64da8a40b62cf6f10b7a327ca1bb3d505

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.27)
+    brainiac (0.0.29)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.27)
+  brainiac (0.0.29)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/README.md

@@ -226,12 +226,23 @@ Configure which AI CLI to use for dispatching agents. Each provider is a JSON fi
 
 ```json
 {
-  "agent_cli": "kiro-cli",
-  "agent_cli_args": "chat --trust-all-tools --no-interactive",
-  "agent_model_flag": "--model"
+  "binary": "kiro-cli",
+  "default_args": "chat --trust-all-tools --no-interactive",
+  "agent_flag": "--agent",
+  "model_flag": "--model"
 }
 ```
 
+The `agent_flag` field controls how agent identity is passed to the CLI. Different CLIs use different flags:
+
+| CLI | `agent_flag` | Example command |
+|-----|-------------|-----------------|
+| Kiro CLI | `"--agent"` | `kiro-cli --agent sherlock chat --no-interactive` |
+| Codex CLI | `"--profile"` | `codex --profile sherlock exec --sandbox workspace-write -` |
+| Grok CLI | `null` | `grok --always-approve` (no agent identity passed) |
+
+Set `agent_flag` to `null` to suppress passing the agent name entirely (for CLIs that don't support persona switching).
+
 Brainiac ships with example providers during setup. Your project config references which provider to use.
 
 #### 3. Environment Variables

data/bin/brainiac

@@ -205,6 +205,7 @@ def wait_for_agents_to_finish
   end
 end
 
+# rubocop:disable Naming/PredicateMethod
 def stop_server
   pid = find_server_pid
 
@@ -245,6 +246,7 @@ def stop_server
     false
   end
 end
+# rubocop:enable Naming/PredicateMethod
 
 # Kill a single process: TERM first, KILL if it doesn't exit within 5s.
 def kill_pid(pid, quiet: false)
@@ -1025,6 +1027,9 @@ def brain_list
   puts "Run 'brainiac brain init <agent-name>' to set up a new agent."
 end
 
+# Model output parsing (shared with lib/brainiac/helpers.rb)
+require_relative "../lib/brainiac/model_parser"
+
 # Main CLI
 options = {}
 subcommand = ARGV.shift
@@ -1940,6 +1945,150 @@ when "provider"
     File.write(file, JSON.pretty_generate(scaffold))
     puts "Created #{file} — edit it to configure the provider."
 
+  when "list-models"
+    name = ARGV[0]
+    unless name
+      puts "Usage: brainiac provider list-models <name>"
+      exit 1
+    end
+    file = File.join(providers_dir, "#{name}.json")
+    unless File.exist?(file)
+      puts "Provider '#{name}' not found."
+      exit 1
+    end
+    data = JSON.parse(File.read(file))
+    command = data["list_models_command"]
+    if command.nil? || command.empty?
+      puts "Provider '#{name}' has no list_models_command configured."
+      puts "Edit #{file} and set \"list_models_command\" to a shell command that lists models."
+      puts "Example: \"kiro-cli chat --list-models --format json\""
+      exit 1
+    end
+
+    puts "Querying models from '#{name}' (#{command})..."
+    puts ""
+    stdout, stderr, status = Open3.capture3(command)
+    unless status.success?
+      puts "Command failed (exit #{status.exitstatus}):"
+      puts stderr.strip unless stderr.empty?
+      exit 1
+    end
+
+    models = parse_list_models_output(stdout)
+    if models.nil? || models.empty?
+      puts "No models found in command output."
+      puts "Raw output:"
+      puts stdout
+      exit 1
+    end
+
+    # Filter hidden models (e.g. codex "visibility": "hide") unless none are visible
+    visible_models = models.select { |m| m["visibility"].nil? || m["visibility"] != "hide" }
+    visible_models = models if visible_models.empty?
+
+    # Display models in a table
+    default_model = data["default_model"]
+    # Determine default: explicit default_model field > parsed "default" flag > first model
+    has_explicit_default = default_model && visible_models.any? { |m| m["model_id"] == default_model }
+    has_parsed_default = !has_explicit_default && visible_models.any? { |m| m["default"] }
+    puts "Available models for '#{name}' (#{visible_models.size} visible, #{models.size} total):"
+    puts ""
+    visible_models.each do |m|
+      model_id = m["model_id"] || "unknown"
+      desc = m["description"] || m["display_name"] || ""
+      rate = m["rate_multiplier"] ? "#{m["rate_multiplier"]}x" : (m["rate"] || "")
+      marker = if has_explicit_default
+                 m["model_id"] == default_model ? "*" : " "
+               elsif has_parsed_default
+                 m["default"] ? "*" : " "
+               else
+                 m == visible_models.first ? "*" : " "
+               end
+      if desc.empty?
+        puts "  #{marker} #{model_id}"
+      else
+        puts format("  %<marker>s %-25<model>s %-15<rate>s %<desc>s", marker: marker, model: model_id, rate: rate, desc: desc)
+      end
+    end
+
+    # Show which are mapped vs unmapped
+    configured = data["models"] || {}
+    configured_ids = configured.values
+    unmapped = visible_models.select do |m|
+      id = m["model_id"]
+      !configured_ids.include?(id) && !configured.key?(id)
+    end
+    unless unmapped.empty?
+      puts ""
+      puts "#{unmapped.size} model(s) not in your provider's 'models' map:"
+      unmapped.each { |m| puts "  - #{m["model_id"]}" }
+      puts ""
+      puts "Run 'brainiac provider sync-models #{name}' to add them."
+    end
+
+  when "sync-models"
+    name = ARGV[0]
+    unless name
+      puts "Usage: brainiac provider sync-models <name>"
+      exit 1
+    end
+    file = File.join(providers_dir, "#{name}.json")
+    unless File.exist?(file)
+      puts "Provider '#{name}' not found."
+      exit 1
+    end
+    data = JSON.parse(File.read(file))
+    command = data["list_models_command"]
+    if command.nil? || command.empty?
+      puts "Provider '#{name}' has no list_models_command configured."
+      exit 1
+    end
+
+    stdout, stderr, status = Open3.capture3(command)
+    unless status.success?
+      puts "Command failed (exit #{status.exitstatus}): #{stderr.strip}"
+      exit 1
+    end
+
+    models = parse_list_models_output(stdout)
+    if models.nil? || models.empty?
+      puts "No models found in command output."
+      exit 1
+    end
+
+    # Build a models map from discovered models: key = short name, value = model_id
+    existing_models = data["models"] || {}
+    new_models = existing_models.dup
+    added = []
+
+    models.each do |m|
+      model_id = m["model_id"]
+      next unless model_id
+
+      # Skip hidden models (e.g. codex internal models)
+      next if m["visibility"] == "hide"
+
+      # Skip if already mapped (as key or value)
+      next if new_models.value?(model_id) || new_models.key?(model_id)
+
+      # Generate a short key: strip common prefixes, use the base name
+      short_key = generate_short_model_key(model_id)
+      # If the short key already exists, use the full model_id as the key
+      short_key = model_id if new_models.key?(short_key)
+      new_models[short_key] = model_id
+      added << "#{short_key} => #{model_id}"
+    end
+
+    if added.empty?
+      puts "All discovered models are already mapped. Nothing to sync."
+      exit 0
+    end
+
+    data["models"] = new_models
+    File.write(file, JSON.pretty_generate(data))
+    puts "Synced #{added.size} new model(s) to #{file}:"
+    added.each { |a| puts "  + #{a}" }
+
   else
     puts <<~HELP
       Usage: brainiac provider <command>
@@ -1948,6 +2097,8 @@ when "provider"
         list                 List configured CLI providers
         show <name>          Show provider configuration
         add <name>           Create a new provider config
+        list-models <name>   Query available models from the CLI provider
+        sync-models <name>   Add discovered models to provider config
     HELP
   end
 
@@ -3474,7 +3625,7 @@ when "plugin"
     gem_name = "brainiac-#{plugin_name}"
 
     # Determine the base repo path (strip worktree suffix like --branch-name)
-    base_path = current_path.sub(/--[^\/]+$/, "")
+    base_path = current_path.sub(%r{--[^/]+$}, "")
     unless Dir.exist?(base_path)
       puts "Error: Base repo not found at #{base_path}"
       exit 1
@@ -3503,9 +3654,7 @@ when "plugin"
     # Fetch latest to make sure the branch is available
     puts "Fetching latest from origin..."
     _out, _err, fetch_status = Open3.capture3("git", "fetch", "origin", chdir: base_path)
-    unless fetch_status.success?
-      puts "Warning: git fetch failed — continuing with local state."
-    end
+    puts "Warning: git fetch failed — continuing with local state." unless fetch_status.success?
 
     # Check if a worktree already exists for this branch
     worktree_list, _, wt_status = Open3.capture3("git", "worktree", "list", "--porcelain", chdir: base_path)
@@ -3513,18 +3662,19 @@ when "plugin"
 
     if wt_status.success?
       # Parse porcelain output to find worktrees on the target branch
-      worktrees = worktree_list.split("\n\n").map do |block|
+      worktree_blocks = worktree_list.split("\n\n").map do |block|
         wt = {}
         block.each_line do |line|
           case line
           when /^worktree (.+)/
             wt[:path] = Regexp.last_match(1).strip
-          when /^branch refs\/heads\/(.+)/
+          when %r{^branch refs/heads/(.+)}
             wt[:branch] = Regexp.last_match(1).strip
           end
         end
         wt
-      end.select { |wt| wt[:path] && wt[:branch] }
+      end
+      worktrees = worktree_blocks.select { |wt| wt[:path] && wt[:branch] }
 
       target_worktree = worktrees.find { |wt| wt[:branch] == branch_name }
     end
@@ -3541,11 +3691,9 @@ when "plugin"
       File.write(plugins_file, JSON.pretty_generate(plugins_config))
       puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
       puts "  Path: #{new_path}"
-      puts "  Restart the server to apply: brainiac restart"
     else
       # Check if branch exists remotely or locally
-      branch_exists = false
-      check_cmd, _, check_status = Open3.capture3("git", "rev-parse", "--verify", "origin/#{branch_name}", chdir: base_path)
+      _, _, check_status = Open3.capture3("git", "rev-parse", "--verify", "origin/#{branch_name}", chdir: base_path)
       branch_exists = check_status.success?
 
       unless branch_exists
@@ -3576,7 +3724,10 @@ when "plugin"
       _, _, local_check = Open3.capture3("git", "rev-parse", "--verify", branch_name, chdir: base_path)
       if !local_check.success? && check_status.success?
         # Remote branch exists but not local — create tracking branch in worktree
-        _, stderr, wt_status = Open3.capture3("git", "worktree", "add", "--track", "-b", branch_name, worktree_dir, "origin/#{branch_name}", chdir: base_path)
+        _, stderr, wt_status = Open3.capture3(
+          "git", "worktree", "add", "--track", "-b", branch_name, worktree_dir,
+          "origin/#{branch_name}", chdir: base_path
+        )
       else
         # Local branch exists — use it directly
         _, stderr, wt_status = Open3.capture3("git", "worktree", "add", worktree_dir, branch_name, chdir: base_path)
@@ -3592,8 +3743,8 @@ when "plugin"
       File.write(plugins_file, JSON.pretty_generate(plugins_config))
       puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
       puts "  Worktree: #{worktree_dir}"
-      puts "  Restart the server to apply: brainiac restart"
     end
+    puts "  Restart the server to apply: brainiac restart"
 
   else
     puts "Usage: brainiac plugin <command>"

data/docs/resume.md

@@ -0,0 +1,87 @@
+# Resume Session Integration
+
+Brainiac supports resuming prior agent sessions instead of starting fresh. Two patterns exist:
+
+## Flag-Based Resume (e.g. Kiro `--resume`, Grok `-c`)
+
+The CLI appends a flag to the existing command. The base command structure stays the same.
+
+```
+kiro-cli --agent sherlock chat --trust-all-tools --no-interactive --resume
+grok --always-approve -c
+```
+
+Provider config:
+
+```json
+{
+  "resume_flag": "--resume"
+}
+```
+
+## Subcommand-Based Resume (e.g. Codex `exec resume --last`)
+
+The CLI changes the subcommand entirely. The base command structure is replaced.
+
+```
+codex exec --full-auto          →  codex exec resume --last --full-auto
+```
+
+Provider config:
+
+```json
+{
+  "resume_flag": null,
+  "resume_args": "exec resume --last --full-auto",
+  "session_dir": "~/.codex/sessions"
+}
+```
+
+When `resume_args` is set, it replaces `default_args` entirely during resume. The `session_dir` field tells Brainiac where to look for prior sessions (for CLIs that store session state centrally rather than in the project directory).
+
+## Plugin Integration Contract
+
+Plugins that want to support resume MUST:
+
+1. **Use `resume_viable?`** to check whether a session can be resumed:
+
+   ```ruby
+   can_resume = resume_viable?(project_config: config, chdir: worktree_path)
+   ```
+
+2. **Pass `resume: true` to `run_agent`** — core handles the rest:
+
+   ```ruby
+   run_agent(prompt, project_config: config, chdir: worktree_path, resume: can_resume)
+   ```
+
+Plugins MUST NOT:
+- Check `resolved["resume_flag"]` directly (misses `resume_args` providers)
+- Call `resolve_resume` directly (internal to `run_agent`)
+- Build their own resume command logic
+
+## How It Works Internally
+
+```
+Plugin calls run_agent(..., resume: true)
+  → run_agent calls resolve_resume(true, resolved, chdir)
+    → resolve_resume checks resume_flag OR resume_args is configured
+    → resolve_resume calls prior_session_exists?(chdir, cli, session_dir:)
+      → For centralized session dirs: scans .jsonl files for matching cwd
+      → For local session dirs: checks for .grok/, .kiro-cli/, or recent logs
+    → Returns :resume_args, flag string, or false
+  → run_agent passes result to build_agent_cmd
+    → :resume_args → replace default_args with resume_args
+    → String flag → append to command
+    → false → normal command (no resume)
+```
+
+## Session Detection
+
+### Local (flag-based CLIs)
+
+Checks for CLI-specific dotdirs (`.grok/`, `.kiro-cli/`) or recent agent logs in `tmp/` (last 24 hours).
+
+### Centralized (subcommand-based CLIs)
+
+Scans `session_dir` for `.jsonl` files modified in the last 24 hours whose first-line JSON metadata contains a `payload.cwd` matching the target working directory. Handles symlink resolution (e.g. `/var/folders` vs `/private/var/folders` on macOS).

data/lib/brainiac/cron.rb

@@ -596,10 +596,12 @@ def build_cron_agent_cmd(job, project, prompt_file: nil)
   resolved = resolve_project_cli_config(project, agent_name: job[:agent])
   agent_flag = resolved.key?("agent_flag") ? resolved["agent_flag"] : "--agent"
   cmd = [resolved["agent_cli"]]
+  # cwd_flag: pass the working directory as a CLI argument (e.g. -C for Codex CLI).
+  cmd.push(resolved["cwd_flag"], project["repo_path"]) if resolved["cwd_flag"] && project["repo_path"]
   cmd.push(agent_flag, agent_config_name) if agent_flag
   cmd.concat(resolved["agent_cli_args"].split)
   cmd.push(resolved["agent_model_flag"], job[:model]) if resolved["agent_model_flag"]&.length&.positive? && job[:model]
-  cmd.push(resolved["agent_effort_flag"], job[:effort]) if resolved["agent_effort_flag"]&.length&.positive? && job[:effort]
+  append_effort_to_cmd(cmd, job[:effort], resolved)
   cmd.push(resolved["prompt_flag"], prompt_file) if prompt_file && resolved["prompt_mode"] == "flag" && resolved["prompt_flag"]
   cmd
 end