brainiac-github 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 708e7c1fc05829642c2f04b08c5d12eb3350bcf40f6cfbd7b923e94252718d33
-  data.tar.gz: de33a6acca8074115ea7c8102828acc830eb2f43e453407273156acb6bc6e274
+  metadata.gz: 49d9d73cefe9f24ff840f683ea53a4ff2276cbd89495037765dcc65fb3370fae
+  data.tar.gz: 9de4f939b32f3f7c6f802d64e5a5280cc2de108fc771212b865bb17b8a12d21e
 SHA512:
-  metadata.gz: 707cec265ade4657632ce8ac14a17c30e6658b8fdf61e403b0375d9979d3aae2db05f6c16c0c830dadc257a66839de4f435f70de185ac2446cd3d3ccab331286
-  data.tar.gz: f645bfe2c9d66169a1a0293920919f7783776a784363c9892264419b87ee88b81ba8243828d256f54bf44e6b9637a51c787496f2eacb217c3fc42558dab34ca3
+  metadata.gz: f3b54d02be22dbc9072aa3170a7073ef912b40f9555b5fdfde9a0cea3c4212fcf84c5e797026cdf094b1ef4e220804784a30361e64377e00470a785e6481d2e6
+  data.tar.gz: 6cc367893d43b6276e141902e21b17e48c416a84c76e989bc0d34620223ee47b52fd02ec01650684e3adde7410d39ac42e9de8eeece11a895c43aea2e7d1b414

data/lib/brainiac/plugins/github/handler.rb

@@ -4,6 +4,17 @@ module Brainiac
   module Plugins
     module Github
       module Handler
+        # Marker that starts every crash-notification comment (see register_crash_handler!).
+        CRASH_COMMENT_PREFIX = "💥"
+
+        # Circuit breaker: max comment dispatches per (repo, PR, agent) within the window.
+        # Stops any comment -> dispatch -> crash -> comment feedback loop, regardless of
+        # who posted the comment or what it says.
+        COMMENT_DISPATCH_LIMIT = 4
+        COMMENT_DISPATCH_WINDOW = 120 # seconds
+        COMMENT_DISPATCH_LOCK = Mutex.new
+        COMMENT_DISPATCH_TIMES = Hash.new { |h, k| h[k] = [] }
+
         class << self
           def handle_pr_merged(payload)
             pr = payload["pull_request"]
@@ -181,13 +192,14 @@ module Brainiac
             result = find_work_item_by_branch(branch)
 
             if result
-              _internal_id, card_info = result
+              work_item_id, card_info = result
               card_number = extract_card_number(card_info)
               unless card_number
                 LOG.warn "Card has no number — can't dispatch review"
                 return [200, { status: "ignored", reason: "card has no number" }.to_json]
               end
             else
+              work_item_id = nil
               card_info = {}
               card_number = nil
             end
@@ -236,7 +248,7 @@ module Brainiac
             card_context = card_number ? " for card ##{card_number}" : ""
             LOG.info "PR review submitted by #{reviewer} on PR ##{pr_number}#{card_context} (project: #{project_key})"
             dispatch_pr_review(card_number, card_key, card_info, pr_number, review, reviewer,
-                               repo_name, project_key, project_config, repo_path)
+                               repo_name, project_key, project_config, repo_path, work_item_id: work_item_id)
 
             [200, { status: "processed", card: card_number, pr: pr_number, reviewer: reviewer, project: project_key }.to_json]
           rescue StandardError => e
@@ -253,20 +265,8 @@ module Brainiac
             comment_user_type = comment.dig("user", "type")
             repo_name = payload.dig("repository", "full_name")
 
-            unless issue["pull_request"]
-              LOG.info "Issue comment on non-PR issue ##{issue["number"]}, ignoring"
-              return [200, { status: "ignored", reason: "not a PR comment" }.to_json]
-            end
-
-            # If the PR was opened by a remote agent bot (not local to this machine),
-            # skip dispatch — the other machine that owns the agent will handle it.
-            pr_author = issue.dig("user", "login")
-            pr_author_type = issue.dig("user", "type")
-            unless pr_author_owned_locally?(pr_author, pr_author_type)
-              pr_number = issue["number"]
-              LOG.info "[GitHub] PR ##{pr_number} owned by remote agent (#{pr_author}) — skipping dispatch"
-              return [200, { status: "ignored", reason: "PR owned by remote agent" }.to_json]
-            end
+            rejection = issue_comment_rejection(issue, comment_body)
+            return rejection if rejection
 
             project_result = identify_project_by_repo(repo_name)
             unless project_result
@@ -300,6 +300,12 @@ module Brainiac
             bot_ignore_reason = bot_comment_ignore_reason(comment_user, comment_user_type, agent_name, pr_number)
             return bot_ignore_reason if bot_ignore_reason
 
+            if comment_dispatch_throttled?(repo_name, pr_number, agent_name)
+              LOG.warn "[GitHub] PR ##{pr_number}: >#{COMMENT_DISPATCH_LIMIT} dispatches for #{agent_name} in " \
+                       "#{COMMENT_DISPATCH_WINDOW}s — possible loop, ignoring comment"
+              return [200, { status: "ignored", reason: "dispatch rate limit" }.to_json]
+            end
+
             branch = fetch_pr_branch(repo_name, pr_number, agent_name, project_config)
             result = find_work_item_by_branch(branch)
 
@@ -420,6 +426,42 @@ module Brainiac
             pr_author_owned_locally?(pr_author, pr_author_type)
           end
 
+          # Early-exit guards for issue_comment events. Returns a Rack-style response
+          # array when the comment should be ignored, or nil to continue dispatch.
+          def issue_comment_rejection(issue, comment_body)
+            unless issue["pull_request"]
+              LOG.info "Issue comment on non-PR issue ##{issue["number"]}, ignoring"
+              return [200, { status: "ignored", reason: "not a PR comment" }.to_json]
+            end
+
+            # If the PR was opened by a remote agent bot (not local to this machine),
+            # skip dispatch — the other machine that owns the agent will handle it.
+            pr_author = issue.dig("user", "login")
+            pr_author_type = issue.dig("user", "type")
+            unless pr_author_owned_locally?(pr_author, pr_author_type)
+              LOG.info "[GitHub] PR ##{issue["number"]} owned by remote agent (#{pr_author}) — skipping dispatch"
+              return [200, { status: "ignored", reason: "PR owned by remote agent" }.to_json]
+            end
+
+            # Crash notifications are posted via `gh` as the human's account when the app
+            # client isn't configured, so the bot-login checks below can't catch them.
+            # Without this guard each crash comment re-dispatches the agent, which crashes
+            # again, forever.
+            if crash_notification_comment?(comment_body)
+              LOG.info "[GitHub] Ignoring crash notification comment on PR ##{issue["number"]}"
+              return [200, { status: "ignored", reason: "crash notification" }.to_json]
+            end
+
+            nil
+          end
+
+          # True when a comment is a crash notification posted by the crash handler.
+          # These are posted via `gh` as the human account when no app client is
+          # configured, so the bot-login checks can't catch them — match on the prefix.
+          def crash_notification_comment?(comment_body)
+            comment_body.to_s.lstrip.start_with?(CRASH_COMMENT_PREFIX)
+          end
+
           # Check PR ownership given the author login and account type.
           # Used by both pull_request_review (has full PR object) and issue_comment
           # (has issue.user which is the PR author on PR-linked issues).
@@ -630,6 +672,20 @@ module Brainiac
           # 1. Self-triggered: bot matches the dispatching agent (prevents loops)
           # 2. Remote agent: bot matches a known agent that isn't local (other machine handles it)
           # Allows: cross-agent LOCAL bot comments (e.g. GLaDOS commenting on Galen's PR)
+          # Records a dispatch attempt; true when the (repo, PR, agent) is over the limit.
+          def comment_dispatch_throttled?(repo_name, pr_number, agent_name)
+            key = [repo_name, pr_number, agent_name.to_s.downcase]
+            now = Time.now.to_f
+            COMMENT_DISPATCH_LOCK.synchronize do
+              times = COMMENT_DISPATCH_TIMES[key]
+              times.reject! { |t| now - t > COMMENT_DISPATCH_WINDOW }
+              return true if times.size >= COMMENT_DISPATCH_LIMIT
+
+              times << now
+              false
+            end
+          end
+
           def bot_comment_ignore_reason(comment_user, comment_user_type, agent_name, pr_number)
             return nil unless comment_user_type == "Bot"
 
@@ -742,23 +798,15 @@ module Brainiac
 
             intent_ctx = fetch_pr_intent_context(pr_number, repo_name, agent_name)
             agent_env = github_agent_env(agent_name, repo_name)
-            # detect_model_explicit is newer core; fall back to detect_model on older builds.
-            if respond_to?(:detect_model_explicit)
-              comment_model, comment_model_explicit = detect_model_explicit(project_config, text: comment_body)
-            else
-              comment_model = detect_model(project_config, text: comment_body)
-              comment_model_explicit = nil
-            end
             run_agent_opts = { project_config: project_config, chdir: worktree,
                                log_name: "pr-comment-#{pr_number}",
-                               model: comment_model,
-                               effort: detect_effort(project_config, text: comment_body),
                                agent_name: agent_name, source: :github,
                                source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: worktree },
                                message: comment_body, channel: "GitHub PR comment",
                                context: intent_ctx }
+            work_item_id = find_work_item_by_worktree(worktree)&.first if respond_to?(:find_work_item_by_worktree, true)
+            run_agent_opts.merge!(dispatch_override_opts(project_config, comment_body, agent_name, work_item_id))
             run_agent_opts[:env] = agent_env if method(:run_agent).parameters.flatten.include?(:env)
-            run_agent_opts[:explicit_model] = comment_model_explicit if method(:run_agent).parameters.flatten.include?(:explicit_model)
             pid, log_file = run_agent(prompt, **run_agent_opts)
             return unless pid
 
@@ -766,7 +814,7 @@ module Brainiac
           end
 
           def dispatch_pr_review(card_number, card_key, card_info, pr_number, review, reviewer,
-                                 repo_name, project_key, project_config, repo_path)
+                                 repo_name, project_key, project_config, repo_path, work_item_id: nil)
             review_id = review["id"]
             agent_name = resolve_work_item_agent(card_info, project_config)
 
@@ -809,6 +857,7 @@ module Brainiac
                                source_context: { pr_number: pr_number, repo_name: repo_name, work_dir: work_dir },
                                message: review["body"], channel: "GitHub PR review",
                                context: fetch_pr_intent_context(pr_number, repo_name, agent_name) }
+            run_agent_opts.merge!(dispatch_override_opts(project_config, review["body"].to_s, agent_name, work_item_id))
             run_agent_opts[:env] = agent_env if method(:run_agent).parameters.flatten.include?(:env)
             pid, log_file = run_agent(prompt, **run_agent_opts)
             return unless pid
@@ -816,6 +865,36 @@ module Brainiac
             register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
           end
 
+          # run_agent options for the CLI provider, model, effort and profile of a dispatch.
+          # Core's resolve_dispatch_overrides parses the [cli:X]/[model]/[effort:X]/[p:X] tags,
+          # falls back to the work item's stored overrides (so a card switched to claude in
+          # Fizzy stays on claude for PR comments), resolves the model through the provider
+          # that will actually run, and persists new tags. Older core builds lack it, so fall
+          # back to the per-tag detectors there.
+          def dispatch_override_opts(project_config, text, agent_name, work_item_id)
+            supported = method(:run_agent).parameters.flatten
+            opts = if respond_to?(:resolve_dispatch_overrides, true)
+                     overrides = resolve_dispatch_overrides(project_config, text: text, agent_name: agent_name,
+                                                                            work_item_id: work_item_id)
+                     { cli_provider: overrides[:cli_provider], model: overrides[:model], effort: overrides[:effort],
+                       profile: overrides[:profile], explicit_model: overrides[:explicit_model] }
+                   else
+                     legacy_override_opts(project_config, text)
+                   end
+            opts.compact.slice(*supported)
+          end
+
+          def legacy_override_opts(project_config, text)
+            cli_provider = respond_to?(:detect_cli_provider, true) ? detect_cli_provider(text: text) : nil
+            if respond_to?(:detect_model_explicit, true)
+              model, explicit = detect_model_explicit(project_config, text: text, cli_provider_override: cli_provider)
+            else
+              model = detect_model(project_config, text: text)
+            end
+            { cli_provider: cli_provider, model: model, explicit_model: explicit,
+              effort: detect_effort(project_config, text: text) }
+          end
+
           def build_review_context(reviewer, review, pr_number, repo_name, agent_key = nil)
             context = "GitHub PR Review from @#{reviewer}:\n\n"
             context += "Review body:\n#{review["body"]}\n\n" if review["body"] && !review["body"].empty?

data/lib/brainiac/plugins/github/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Github
-      VERSION = "0.3.2"
+      VERSION = "0.3.4"
     end
   end
 end

data/lib/brainiac/plugins/github.rb

@@ -67,7 +67,8 @@ module Brainiac
             agent_key = ctx[:agent_key]
             snippet = ctx[:snippet]
             snippet_block = snippet ? "\n```\n#{snippet[-1500..]}\n```" : ""
-            comment_body = "💥 **#{agent_display} crashed** (exit code #{ctx[:exit_status]})\n\nLog: `#{ctx[:log_file]}`#{snippet_block}"
+            comment_body = "#{Handler::CRASH_COMMENT_PREFIX} **#{agent_display} crashed** " \
+                           "(exit code #{ctx[:exit_status]})\n\nLog: `#{ctx[:log_file]}`#{snippet_block}"
 
             begin
               if AppClient.configured?(agent_key)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-github
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Andy Davis