brainiac-basecamp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 513a24a33fad368f0f563ac5d06c76dccaacbd0aff2eb681fedd8860d9866db3
-  data.tar.gz: 39eb703375c5757c66443de641534c8b495147b07be6ce3339ec0a2a311bbba8
+  metadata.gz: 630e96430ff517dde6be1c3766ad6f984bb86a4e0b876d55b5d2f205050fbc19
+  data.tar.gz: b6711ef8f8fd3aec32b3f09aea604dee8c7d138f25f4cd03b94096a9787f218a
 SHA512:
-  metadata.gz: 1a0b1c33b666d782f40f8203676369d30fa5b38d0e0b4ce43b880197dfe0caa968cd8bb9197a1027a7ff551003af56f22552e84be966c303ee2fab335560afbe
-  data.tar.gz: e34a0b748449f3736c32c7e4ea35a51edf3940bb6334b0577e7dd48341da11b5988bb1dbaa59645c77ffb2399c0d0f9e24a822aeb61d760cd01ebb511ea4e0f3
+  metadata.gz: cb20e71bf28a7a66cd777245b1751ca363c13ac9062e113045c6316b921bc1ed794aa3f856a62d72f988699e452d4f5ef0ec1fb518d6c5b0324f3559ff4e387a
+  data.tar.gz: f2ef017df5c1b146c31e16fcb030bdb660c13e97d336cb96735d848a278cfc657f9e0cad2d96d12269a79884426835157534f0ad6243fb111d6fa39dc5c68fc8

data/lib/brainiac/plugins/basecamp/hooks.rb

@@ -214,8 +214,16 @@ module Brainiac
                   # All gates have reviewed — dispatch implementation agent to address ALL feedback
                   LOG.info "[Basecamp:Hooks] All gates responded for card ##{card_number} — dispatching fixes" if defined?(LOG)
                   task["status"] = "in_flight"
+                  task.delete("changes_debounce_started")
                   save_epic_state(epic)
-                  # brainiac-github will dispatch the impl agent since this is changes_requested
+
+                  # Re-assign card to implementation agent to trigger dispatch
+                  impl_agent = epic["agent"]
+                  fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
+                  if fizzy_user_id
+                    LOG.info "[Basecamp:Hooks] Re-assigning card ##{card_number} to #{impl_agent} for fixes" if defined?(LOG)
+                    safe_assign_card(card_number, fizzy_user_id)
+                  end
                 else
                   # Wait for remaining gates to respond
                   responded = (task["gate_approvals"]&.size || 0) + (task["changes_requested_by"]&.size || 0)
@@ -242,7 +250,7 @@ module Brainiac
                         save_epic_state(epic_reloaded)
                         # Re-assign card to trigger dispatch
                         fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, epic_reloaded["agent"])
-                        Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id) if fizzy_user_id
+                        safe_assign_card(card_number, fizzy_user_id) if fizzy_user_id
                       end
                     rescue StandardError => e
                       LOG.error "[Basecamp:Hooks] Debounce dispatch failed: #{e.message}" if defined?(LOG)
@@ -314,8 +322,46 @@ module Brainiac
             false
           end
 
+          # Safely assign a card to a user, checking if they're already assigned first.
+          # Fizzy's assign command TOGGLES assignment, so calling it when already assigned
+          # will unassign the user. This method prevents that.
+          #
+          # @param card_number [Integer, String] Fizzy card number
+          # @param fizzy_user_id [String] Fizzy user ID to assign
+          # @return [Boolean] true if assigned, false if already assigned or failed
+          def safe_assign_card(card_number, fizzy_user_id)
+            return false unless fizzy_user_id
+
+            # Check current assignees
+            stdout, _, status = Open3.capture3("fizzy", "card", "show", card_number.to_s, "--json")
+            if status.success?
+              card_data = JSON.parse(stdout).dig("data") rescue nil
+              if card_data
+                current_assignees = (card_data["assignees"] || []).map { |a| a["id"] }
+                if current_assignees.include?(fizzy_user_id)
+                  LOG.info "[Basecamp:Hooks] User #{fizzy_user_id} already assigned to ##{card_number}, skipping" if defined?(LOG)
+                  return false
+                end
+              end
+            end
+
+            # Not assigned — safe to assign
+            _, stderr, status = Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+            if status.success?
+              LOG.info "[Basecamp:Hooks] Assigned ##{card_number} to #{fizzy_user_id}" if defined?(LOG)
+              true
+            else
+              LOG.error "[Basecamp:Hooks] Failed to assign ##{card_number}: #{stderr.strip}" if defined?(LOG)
+              false
+            end
+          rescue StandardError => e
+            LOG.error "[Basecamp:Hooks] Error in safe_assign_card: #{e.message}" if defined?(LOG)
+            false
+          end
+
           # When a PR is updated (new commits pushed) — re-trigger gates if in review.
           # This handles the "Galen fixes → pushes → gates re-review" flow.
+          # Also catches edge cases where gates weren't dispatched initially.
           def register_pr_synchronized
             Brainiac.on(:pr_synchronized) do |ctx|
               card_number = ctx[:card_number]
@@ -326,10 +372,9 @@ module Brainiac
               next unless epic["review_gate"] == "epic_branch" && ReviewGate.enabled?
 
               task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
-              # Only re-trigger if the task is in_flight (fixes pushed) and had prior reviews
-              # Check for ANY prior reviews (approvals OR changes_requested)
-              had_prior_reviews = task["gate_approvals"]&.any? || task["changes_requested_by"]&.any?
-              next unless task && task["status"] == "in_flight" && had_prior_reviews
+              # Re-trigger gates if task is in_flight (agent working/pushed fixes)
+              # No need to check for prior reviews — if task is in_flight with a PR, gates should review
+              next unless task && task["status"] == "in_flight" && task["pr_number"]
 
               LOG.info "[Basecamp:Hooks] PR updated for card ##{card_number} — re-triggering review gates" if defined?(LOG)
 
@@ -565,6 +610,22 @@ module Brainiac
 
             LOG.info "[Basecamp:Hooks] Dispatching #{agent_name} for final decision on card ##{card_number}" if defined?(LOG)
 
+            # Get project config first — we need it for PR check and agent dispatch
+            projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+            projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+            project_config = projects[project_key]
+            github_repo = project_config&.dig("github_repo")
+
+            # Check if PR is already merged (handles manual merges, webhook misses, etc.)
+            if github_repo && pr_number
+              pr_state, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
+              if pr_state.strip == "MERGED"
+                LOG.info "[Basecamp:Hooks] PR ##{pr_number} already merged — marking card ##{card_number} complete" if defined?(LOG)
+                Orchestrator.on_card_completed(card_number)
+                return
+              end
+            end
+
             # Mark task as awaiting final decision
             task["awaiting_final_decision"] = true
             task["status"] = "final_decision"
@@ -582,10 +643,6 @@ module Brainiac
               end
             end
 
-            # Get project config and repo path
-            projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
-            projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
-            project_config = projects[project_key]
             repo_path = project_config&.dig("repo_path")
 
             unless repo_path

data/lib/brainiac/plugins/basecamp/orchestrator.rb

@@ -623,6 +623,12 @@ module Brainiac
 
           # Complete the entire epic.
           def complete_epic(epic)
+            # Idempotency — don't complete twice
+            if epic["status"] == "complete"
+              LOG.info "[Basecamp:Orchestrator] Epic '#{epic['title']}' already complete, skipping duplicate completion" if defined?(LOG)
+              return
+            end
+
             epic["status"] = "complete"
             epic["completed_at"] = Time.now.iso8601
             epic["updated_at"] = Time.now.iso8601

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Basecamp
-      VERSION = "0.0.3"
+      VERSION = "0.0.4"
     end
   end
 end

data/lib/brainiac/plugins/basecamp.rb

@@ -47,9 +47,136 @@ module Brainiac
             end
           end
 
+          # Start background health check thread for active epics
+          start_epic_health_monitor
+
           LOG.info "[Basecamp] Plugin registered (webhook: /basecamp, review_gate: #{Config.review_gate})"
         end
 
+        # Background thread that periodically checks for stuck epic states and auto-heals.
+        # Runs every 90 seconds to catch:
+        # - final_decision tasks where PR is already merged
+        # - in_flight tasks where impl agent isn't assigned
+        # - in_review tasks where all gates have actually approved (webhook missed)
+        def start_epic_health_monitor
+          @health_monitor_thread = Thread.new do
+            loop do
+              sleep 90  # Check every 90 seconds
+
+              begin
+                active_epics = Orchestrator.active_epics
+                next if active_epics.empty?
+
+                active_epics.each do |epic|
+                  health_check_epic(epic)
+                end
+              rescue StandardError => e
+                LOG.error "[Basecamp:HealthCheck] Error: #{e.message}" if defined?(LOG)
+              end
+            end
+          end
+          @health_monitor_thread.abort_on_exception = false
+        end
+
+        # Check an epic for stuck states and auto-heal
+        def health_check_epic(epic)
+          healed_any = false
+
+          epic["tasks"]&.each do |task|
+            card_number = task["fizzy_card"]
+            status = task["status"]
+            pr_number = task["pr_number"]
+            project_key = task["project"]
+
+            case status
+            when "final_decision"
+              # Check if PR is already merged
+              if pr_number && project_key
+                projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+                projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+                github_repo = projects.dig(project_key, "github_repo")
+
+                if github_repo
+                  pr_state, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "state", "-q", ".state")
+                  if pr_state.strip == "MERGED"
+                    LOG.info "[Basecamp:HealthCheck] PR ##{pr_number} merged but task ##{card_number} stuck in final_decision — healing" if defined?(LOG)
+                    Orchestrator.on_card_completed(card_number)
+                    healed_any = true
+                  end
+                end
+              end
+
+            when "in_flight"
+              # Check if impl agent is assigned when changes were requested
+              if task["changes_requested_by"]&.any?
+                impl_agent = epic["agent"]
+                card_json, = Open3.capture2("fizzy", "card", "show", card_number.to_s, "--json")
+                card_data = JSON.parse(card_json) rescue {}
+                assignees = card_data.dig("data", "assignees") || []
+                assignee_names = assignees.map { |a| a["name"]&.downcase }
+
+                unless assignee_names.include?(impl_agent.downcase)
+                  LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight with changes_requested but #{impl_agent} not assigned — healing" if defined?(LOG)
+                  fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
+                  if fizzy_user_id
+                    Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+                    healed_any = true
+                  end
+                end
+              end
+
+            when "in_review"
+              # Check if all gates have actually approved (webhook might have missed)
+              if pr_number && project_key && ReviewGate.enabled?
+                projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+                projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+                repo_path = projects.dig(project_key, "repo_path")
+
+                if repo_path
+                  # Sync from GitHub to catch any missed approvals
+                  sync_result = ReviewGate.sync_from_github(task, repo_path: repo_path)
+
+                  if ReviewGate.all_gates_passed?(task)
+                    # All approved — advance to final_decision
+                    LOG.info "[Basecamp:HealthCheck] All gates passed for ##{card_number} but still in_review — healing" if defined?(LOG)
+                    task["status"] = "final_decision"
+                    task["awaiting_final_decision"] = true
+                    Hooks.send(:save_epic_state, epic)
+                    Hooks.send(:dispatch_final_decision, epic, task, {})
+                    healed_any = true
+                  elsif Hooks.send(:all_gates_responded?, task) && task["changes_requested_by"]&.any?
+                    # All gates responded but some requested changes — need to dispatch impl agent
+                    impl_agent = epic["agent"]
+                    card_json, = Open3.capture2("fizzy", "card", "show", card_number.to_s, "--json")
+                    card_data = JSON.parse(card_json) rescue {}
+                    assignees = card_data.dig("data", "assignees") || []
+                    assignee_names = assignees.map { |a| a["name"]&.downcase }
+
+                    LOG.info "[Basecamp:HealthCheck] All gates responded for ##{card_number} with changes_requested — transitioning to in_flight" if defined?(LOG)
+                    task["status"] = "in_flight"
+                    Hooks.send(:save_epic_state, epic)
+
+                    unless assignee_names.include?(impl_agent.downcase)
+                      LOG.info "[Basecamp:HealthCheck] Re-assigning ##{card_number} to #{impl_agent}" if defined?(LOG)
+                      fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
+                      if fizzy_user_id
+                        Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+                      end
+                    end
+                    healed_any = true
+                  end
+                end
+              end
+            end
+          end
+
+          # If we healed anything, check if we can dispatch more tasks
+          if healed_any
+            Orchestrator.send(:dispatch_unblocked_tasks, epic)
+            Orchestrator.send(:save_epic, epic)
+          end
+        end
+
         private
 
         # Resume active epics on server startup.
@@ -132,11 +259,31 @@ module Brainiac
             task["awaiting_final_decision"] = true
             Hooks.send(:save_epic_state, epic)
             Hooks.send(:dispatch_final_decision, epic, task, {})
+          elsif task["changes_requested_by"]&.any?
+            # Gates requested changes — check if impl agent is assigned
+            impl_agent = epic["agent"]
+            LOG.info "[Basecamp] Resume: ##{card_number} has changes requested, checking assignment" if defined?(LOG)
+
+            # Check current assignees via Fizzy CLI
+            card_json, = Open3.capture2("fizzy", "card", "show", card_number.to_s, "--json")
+            card_data = JSON.parse(card_json) rescue {}
+            assignees = card_data.dig("data", "assignees") || []
+            assignee_names = assignees.map { |a| a["name"]&.downcase }
+
+            if assignee_names.include?(impl_agent.downcase)
+              LOG.info "[Basecamp] Resume: ##{card_number} already assigned to #{impl_agent} — waiting for fixes" if defined?(LOG)
+            else
+              # Re-assign to trigger dispatch
+              LOG.info "[Basecamp] Resume: ##{card_number} not assigned to #{impl_agent} — re-assigning" if defined?(LOG)
+              fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
+              if fizzy_user_id
+                Open3.capture3("fizzy", "card", "assign", card_number.to_s, "--user", fizzy_user_id)
+              end
+            end
           else
-            # Gates haven't all approved — check if we need to dispatch fixes or wait
+            # No changes requested yet — just waiting for reviews
             approvals = task["gate_approvals"]&.size || 0
-            changes = task["changes_requested_by"]&.size || 0
-            LOG.info "[Basecamp] Resume: ##{card_number} has #{approvals} approvals, #{changes} changes_requested — waiting" if defined?(LOG)
+            LOG.info "[Basecamp] Resume: ##{card_number} has #{approvals} approvals, waiting for more reviews" if defined?(LOG)
           end
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-basecamp
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Andy Davis