brainiac-basecamp 0.0.9 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3b4d7d9e99a700f2a533b48110071025bde9eb69b55633acffd4125f88c5540
-  data.tar.gz: 63635c64597b65ed6e0a69e90511010d6975c418249c7a181d9a0349bded7dcc
+  metadata.gz: 1eb44286a14e4c833e7ee753cf3ced44e6579eea0d37ff0c1289db149cc1c97c
+  data.tar.gz: b24e2ed8efe6a611f3d3790dfd38a906cd753c8c766743ab50302f365430d8db
 SHA512:
-  metadata.gz: 37d7d00ab786c8f99318d7098b8a700d8428d0c3db1da4ceaa1040aa924b627b0b886a928cb7f6f1661e35f578403ae4b8911b87a5c48c6bc67a9c0ed5f61c02
-  data.tar.gz: a798eb76376698539c16c54ecdfea9d597893e0f0630c035e9e473401e45b43c0357e4cb6ef8717df704c98543f2bace4754b5f2db6dc97677a46ee8782b2ff9
+  metadata.gz: 106c01e99ca88a0ee5d2801cb632b17fdcace3bd3ea9fe17278cae2cbfa3560f1669c164bf6a12472fc4451bdc81833889aaad2c273b936df77ead50f1736450
+  data.tar.gz: f766419152f38af5404a7640ac87c19540814480e67a1e12ee14621595075d0fc7fc204ed33475022a090c74fbfa97ab8b5a3929c9eedfe3458b2f46345a7fa0

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

@@ -123,6 +123,18 @@ module Brainiac
               if epic_branches.include?(base_branch)
                 LOG.info "[Basecamp:Hooks] PR merged to epic branch #{base_branch} for card ##{card_number} — advancing" if defined?(LOG)
                 Orchestrator.on_card_completed(card_number)
+              elsif epic_branches.empty?
+                # Fallback: epic_branches was never populated (branch creation failed).
+                # If the task is in final_decision or in_review, the merge still represents
+                # completion — advance the epic regardless of which branch was targeted.
+                task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
+                if task && %w[final_decision in_review in_flight].include?(task["status"])
+                  if defined?(LOG)
+                    LOG.warn "[Basecamp:Hooks] epic_branches is empty but PR merged to '#{base_branch}' " \
+                             "for card ##{card_number} (status: #{task['status']}) — advancing anyway (branch creation likely failed)"
+                  end
+                  Orchestrator.on_card_completed(card_number)
+                end
               end
             end
           end
@@ -214,16 +226,12 @@ 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["dispatched_at"] = Time.now.iso8601
                   task.delete("changes_debounce_started")
                   save_epic_state(epic)
 
-                  # 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
+                  # Spawn agent directly — safe_assign_card won't work if already assigned
+                  dispatch_impl_directly(epic, task)
                 else
                   # Wait for remaining gates to respond
                   responded = (task["gate_approvals"]&.size || 0) + (task["changes_requested_by"]&.size || 0)
@@ -246,11 +254,11 @@ module Brainiac
                       if task_reloaded && task_reloaded["status"] == "in_review" && task_reloaded["changes_requested_by"]&.any?
                         LOG.info "[Basecamp:Hooks] Debounce timeout for card ##{card_number} — forcing dispatch" if defined?(LOG)
                         task_reloaded["status"] = "in_flight"
+                        task_reloaded["dispatched_at"] = Time.now.iso8601
                         task_reloaded.delete("changes_debounce_started")
                         save_epic_state(epic_reloaded)
-                        # Re-assign card to trigger dispatch
-                        fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, epic_reloaded["agent"])
-                        safe_assign_card(card_number, fizzy_user_id) if fizzy_user_id
+                        # Spawn agent directly — safe_assign_card won't work if already assigned
+                        dispatch_impl_directly(epic_reloaded, task_reloaded)
                       end
                     rescue StandardError => e
                       LOG.error "[Basecamp:Hooks] Debounce dispatch failed: #{e.message}" if defined?(LOG)
@@ -617,13 +625,32 @@ module Brainiac
             github_repo = project_config&.dig("github_repo")
 
             # Check if PR is already merged (handles manual merges, webhook misses, etc.)
-            if github_repo && pr_number
+            if github_repo && pr_number&.to_i&.positive?
               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
+
+              # SAFEGUARD: Verify PR targets the epic branch (not main/master).
+              # If epic_branches is populated and the PR targets the wrong base, retarget it.
+              epic_branches = epic["epic_branches"] || {}
+              expected_base = epic_branches[project_key] || epic_branches.values.first
+              if expected_base
+                actual_base, = Open3.capture2("gh", "pr", "view", pr_number.to_s, "--repo", github_repo, "--json", "baseRefName", "-q",
+".baseRefName")
+                actual_base = actual_base.strip
+                if !actual_base.empty? && actual_base != expected_base
+                  LOG.warn "[Basecamp:Hooks] PR ##{pr_number} targets '#{actual_base}' but expected '#{expected_base}' — retargeting" if defined?(LOG)
+                  _, stderr, status = Open3.capture3("gh", "pr", "edit", pr_number.to_s, "--repo", github_repo, "--base", expected_base)
+                  if status.success?
+                    LOG.info "[Basecamp:Hooks] Retargeted PR ##{pr_number} to '#{expected_base}'" if defined?(LOG)
+                  elsif defined?(LOG)
+                    LOG.error "[Basecamp:Hooks] Failed to retarget PR ##{pr_number}: #{stderr.strip}"
+                  end
+                end
+              end
             end
 
             # Mark task as awaiting final decision
@@ -663,6 +690,17 @@ module Brainiac
             gate_approvals = task["gate_approvals"] || []
             gate_agents = gate_approvals.map { |a| a["agent"] }.join(", ")
 
+            # Determine expected target branch for the prompt
+            epic_branches = epic["epic_branches"] || {}
+            expected_base = epic_branches[project_key] || epic_branches.values.first
+            target_note = if expected_base
+                            "\n**IMPORTANT:** This PR should target `#{expected_base}` (the epic branch). " \
+                              "If `gh pr view #{pr_number} --json baseRefName` shows a different base, " \
+                              "do NOT merge — report the mismatch instead.\n"
+                          else
+                            ""
+                          end
+
             prompt = <<~PROMPT
               ## Final Decision Required — Fizzy Card ##{card_number}
 
@@ -674,7 +712,7 @@ module Brainiac
                  ```
                  gh pr merge #{pr_number} --squash --delete-branch
                  ```
-
+              #{target_note}
               Note: You cannot self-approve PRs you authored. Merge directly since gates have approved.
 
               After merging, update the Fizzy card with a brief status comment.
@@ -728,14 +766,123 @@ module Brainiac
             end
           end
 
-          def mark_in_review(epic, card_number)
-            task = epic["tasks"].find { |t| t["fizzy_card"] == card_number.to_i }
-            return unless task
+          # Dispatch the implementation agent directly (spawns via run_agent) to address
+          # changes_requested feedback. Used by resume and health-check when the agent is
+          # no longer running but the Fizzy card is still assigned (so safe_assign_card
+          # would bail out with "already assigned, skipping").
+          #
+          # @param epic [Hash] Epic state
+          # @param task [Hash] Task within the epic
+          # @return [void]
+          def dispatch_impl_directly(epic, task)
+            card_number = task["fizzy_card"]
+            agent_name = epic["agent"]
+            pr_number = task["pr_number"]
+            project_key = task["project"]
+            card_key = "changes-requested-#{card_number}"
+
+            # Guard: don't spawn a duplicate if a session is already running for this task
+            session_alive = if defined?(session_active?)
+                              session_active?(card_key)
+                            elsif Object.respond_to?(:session_active?, true)
+                              Object.send(:session_active?, card_key)
+                            else
+                              false
+                            end
+
+            if session_alive
+              LOG.info "[Basecamp:Hooks] Session already active for #{card_key} — skipping dispatch" if defined?(LOG)
+              return
+            end
 
-            task["status"] = "in_review"
-            task["review_started_at"] = Time.now.iso8601
-            epic["updated_at"] = Time.now.iso8601
-            save_epic_state(epic)
+            LOG.info "[Basecamp:Hooks] Direct-dispatching #{agent_name} for changes_requested on card ##{card_number}" if defined?(LOG)
+
+            # Get project config
+            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]
+
+            unless project_config
+              LOG.error "[Basecamp:Hooks] No project config for '#{project_key}' — cannot direct-dispatch" if defined?(LOG)
+              return
+            end
+
+            repo_path = project_config["repo_path"]
+            unless repo_path
+              LOG.error "[Basecamp:Hooks] No repo_path for project '#{project_key}' — cannot direct-dispatch" if defined?(LOG)
+              return
+            end
+
+            # Find the worktree for this card
+            work_items_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "work_items.json")
+            worktree_path = repo_path  # Default to main repo
+            if File.exist?(work_items_file)
+              work_items = JSON.parse(File.read(work_items_file))
+              work_item = work_items.values.find { |wi| wi.dig("sources", "fizzy", "card_number") == card_number }
+              worktree_path = work_item["worktree"] if work_item&.dig("worktree")
+            end
+
+            # Build prompt
+            changers = (task["changes_requested_by"] || []).join(", ")
+            prompt = <<~PROMPT
+              ## Changes Requested — Fizzy Card ##{card_number}
+
+              Review gates have requested changes on your PR#{" ##{pr_number}" if pr_number}.
+              Reviewers who requested changes: #{changers}
+
+              Your job:
+              1. Read the review feedback: #{pr_number ? "`gh pr view #{pr_number} --comments`" : 'check the Fizzy card comments'}
+              2. Address all requested changes
+              3. Commit and push your fixes
+
+              After pushing, update the Fizzy card with a brief status comment noting what you fixed.
+            PROMPT
+
+            # Resolve GitHub App token so agent's `gh` commands run as their bot identity
+            github_repo = project_config&.dig("github_repo")
+            agent_env = github_repo ? ReviewGate.send(:resolve_agent_github_env, agent_name, github_repo) : {}
+
+            # Spawn the agent directly
+            pid = nil
+            log_file = nil
+
+            begin
+              pid, log_file = method(:run_agent).call(
+                prompt,
+                project_config: project_config,
+                chdir: worktree_path,
+                log_name: "changes-requested-#{card_number}",
+                agent_name: agent_name,
+                source: :basecamp,
+                card_number: card_number,
+                env: agent_env
+              )
+            rescue NameError
+              if Object.respond_to?(:run_agent, true)
+                pid, log_file = Object.send(:run_agent,
+                  prompt,
+                  project_config: project_config,
+                  chdir: worktree_path,
+                  log_name: "changes-requested-#{card_number}",
+                  agent_name: agent_name,
+                  source: :basecamp,
+                  card_number: card_number,
+                  env: agent_env)
+              else
+                LOG.warn "[Basecamp:Hooks] run_agent not available — direct impl dispatch skipped" if defined?(LOG)
+                return
+              end
+            end
+
+            # Register session for waybar visibility
+            if pid
+              if defined?(register_session)
+                register_session(card_key, pid, log_file: log_file, agent_name: agent_name)
+              elsif Object.respond_to?(:register_session, true)
+                Object.send(:register_session, card_key, pid, log_file: log_file, agent_name: agent_name)
+              end
+              LOG.info "[Basecamp:Hooks] Spawned #{agent_name} (pid #{pid}) for changes_requested on card ##{card_number}" if defined?(LOG)
+            end
           end
 
           def auto_merge_and_advance(epic, card_number, ctx)

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

@@ -764,14 +764,43 @@ module Brainiac
           end
 
           # Create epic branches for all projects involved in this epic.
+          # CRITICAL: If this fails, epic_branches will be empty and agents will
+          # open PRs against the default branch instead of the epic branch.
+          # We log loudly and retry resolution of project repos if initial attempt fails.
           def create_epic_branches_for(epic)
             project_repos = resolve_project_repos(epic)
-            return if project_repos.empty?
+
+            if project_repos.empty?
+              # Fallback: try to resolve from the basecamp project mapping directly
+              mapped_project = Config.brainiac_project_for(epic["basecamp_project_id"])
+              if mapped_project
+                projects_file = File.join(BRAINIAC_DIR, "projects.json")
+                all_projects = File.exist?(projects_file) ? JSON.parse(File.read(projects_file)) : {}
+                repo = all_projects.dig(mapped_project, "repo_path")
+                project_repos = { mapped_project => repo } if repo
+              end
+            end
+
+            if project_repos.empty?
+              LOG.error "[Basecamp:Orchestrator] Cannot create epic branches — no project repos resolved. " \
+                        "Tasks have projects: #{(epic['tasks'] || []).map { |t| t['project'] }.compact.uniq.inspect}. " \
+                        "Epic will proceed WITHOUT epic branches — PRs will target the default branch!" if defined?(LOG)
+              log_event(epic, "branches_failed", "No project repos resolved — epic branches not created")
+              return
+            end
 
             epic["epic_branches"] = EpicBranch.create_epic_branches(epic, project_repos)
-            log_event(epic, "branches_created", "Epic branches: #{epic['epic_branches'].values.uniq.join(', ')}")
+
+            if epic["epic_branches"].empty?
+              LOG.error "[Basecamp:Orchestrator] create_epic_branches returned empty — branch creation failed" if defined?(LOG)
+              log_event(epic, "branches_failed", "Branch creation returned empty for repos: #{project_repos.keys.join(', ')}")
+            else
+              log_event(epic, "branches_created", "Epic branches: #{epic['epic_branches'].values.uniq.join(', ')}")
+            end
           rescue StandardError => e
-            LOG.error "[Basecamp:Orchestrator] Failed to create epic branches: #{e.message}" if defined?(LOG)
+            LOG.error "[Basecamp:Orchestrator] Failed to create epic branches: #{e.class}: #{e.message}" \
+                      "\n#{e.backtrace.first(3).join("\n")}" if defined?(LOG)
+            log_event(epic, "branches_failed", "Exception: #{e.message}")
           end
 
           # Open final PRs from epic branches to main.

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Basecamp
-      VERSION = "0.0.9"
+      VERSION = "0.0.12"
     end
   end
 end

data/lib/brainiac/plugins/basecamp.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "open3"
 require_relative "basecamp/version"
 require_relative "basecamp/metadata"
 require_relative "basecamp/config"
@@ -99,16 +100,27 @@ module Brainiac
 
             case status
             when "final_decision"
-              # Check if PR is already merged
-              if pr_number && project_key
+              # Check if PR is already merged — resolve pr_number first if missing/zero
+              effective_pr = pr_number
+              if (effective_pr.nil? || effective_pr.zero?) && project_key
+                resolved = resolve_pr_for_task(task)
+                if resolved
+                  task["pr_number"] = resolved[:number]
+                  task["pr_repo"] = resolved[:repo] if resolved[:repo]
+                  effective_pr = resolved[:number]
+                  LOG.info "[Basecamp:HealthCheck] Resolved PR ##{effective_pr} for card ##{card_number}" if defined?(LOG)
+                end
+              end
+
+              if effective_pr&.positive? && 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")
+                  pr_state, = Open3.capture2("gh", "pr", "view", effective_pr.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)
+                    LOG.info "[Basecamp:HealthCheck] PR ##{effective_pr} merged but task ##{card_number} stuck in final_decision — healing" if defined?(LOG)
                     Orchestrator.on_card_completed(card_number)
                     healed_any = true
                   end
@@ -129,25 +141,21 @@ module Brainiac
                   impl_agent = epic["agent"]
                   LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight for #{elapsed.round}s — re-dispatching #{impl_agent}" if defined?(LOG)
 
-                  # Re-dispatch by re-assigning the card (triggers webhook)
+                  # Spawn the agent directly — safe_assign_card won't work if already assigned
                   task["dispatched_at"] = Time.now.iso8601
-                  fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-                  if fizzy_user_id
-                    Hooks.send(:safe_assign_card, card_number, fizzy_user_id)
-                    healed_any = true
-                  end
+                  Hooks.send(:dispatch_impl_directly, epic, task)
+                  healed_any = true
                 end
               elsif task["changes_requested_by"]&.any?
                 # No dispatched_at recorded but changes were requested — legacy state.
                 # Always re-dispatch in this case.
                 impl_agent = epic["agent"]
                 LOG.info "[Basecamp:HealthCheck] Task ##{card_number} in_flight with changes_requested but no dispatched_at — re-dispatching #{impl_agent}" if defined?(LOG)
+
+                # Spawn the agent directly — safe_assign_card won't work if already assigned
                 task["dispatched_at"] = Time.now.iso8601
-                fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-                if fizzy_user_id
-                  Hooks.send(:safe_assign_card, card_number, fizzy_user_id)
-                  healed_any = true
-                end
+                Hooks.send(:dispatch_impl_directly, epic, task)
+                healed_any = true
               end
 
             when "in_review"
@@ -329,13 +337,11 @@ module Brainiac
 
             # Transition to in_flight so the agent gets the right context
             task["status"] = "in_flight"
+            task["dispatched_at"] = Time.now.iso8601
             Hooks.send(:save_epic_state, epic)
 
-            # Re-assign card to trigger a fresh dispatch via the Fizzy webhook
-            fizzy_user_id = Orchestrator.send(:resolve_fizzy_user_id, impl_agent)
-            if fizzy_user_id
-              Hooks.send(:safe_assign_card, card_number, fizzy_user_id)
-            end
+            # Spawn the agent directly — safe_assign_card won't work if already assigned
+            Hooks.send(:dispatch_impl_directly, epic, task)
           else
             # No changes requested yet — check if gates need (re-)dispatching
             approvals = task["gate_approvals"]&.size || 0
@@ -394,6 +400,35 @@ module Brainiac
           card_number = task["fizzy_card"]
           LOG.info "[Basecamp] Resume: checking final_decision task ##{card_number}, awaiting=#{task['awaiting_final_decision']}" if defined?(LOG)
 
+          # First, resolve PR number if missing or zero (branch creation may have failed)
+          pr_number = task["pr_number"]
+          if (pr_number.nil? || pr_number.zero?) && task["project"]
+            resolved_pr = resolve_pr_for_task(task)
+            if resolved_pr
+              task["pr_number"] = resolved_pr[:number]
+              task["pr_repo"] = resolved_pr[:repo] if resolved_pr[:repo]
+              pr_number = resolved_pr[:number]
+              LOG.info "[Basecamp] Resume: resolved PR ##{pr_number} for card ##{card_number}" if defined?(LOG)
+            end
+          end
+
+          # Check if PR is already merged (handles manual merges, webhook misses, agent merges to wrong branch)
+          if pr_number&.positive?
+            project_key = task["project"]
+            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] Resume: PR ##{pr_number} already merged — marking card ##{card_number} complete" if defined?(LOG)
+                Orchestrator.on_card_completed(card_number)
+                return
+              end
+            end
+          end
+
           # If awaiting_final_decision is set, re-dispatch
           # Also handle the case where it's nil but gates are all approved (stale state)
           if task["awaiting_final_decision"] || ReviewGate.all_gates_passed?(task)
@@ -406,6 +441,38 @@ module Brainiac
           end
         end
 
+        # Resolve a PR number for a task by searching GitHub for matching branch patterns.
+        # Used when pr_number is 0 or nil (e.g., branch creation failed so PR was never tracked).
+        def resolve_pr_for_task(task)
+          card_number = task["fizzy_card"]
+          project_key = task["project"]
+          return nil unless 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)) : {}
+          repo_path = projects.dig(project_key, "repo_path")
+          github_repo = projects.dig(project_key, "github_repo")
+          return nil unless repo_path
+
+          # Search for PR by fizzy-NNNN branch pattern (any state)
+          stdout, _, status = Open3.capture3(
+            "gh", "pr", "list", "--state", "all",
+            "--json", "number,headRefName,state",
+            "--jq", ".[] | select(.headRefName | startswith(\"fizzy-#{card_number}\")) | [.number, .state] | @tsv",
+            chdir: repo_path
+          )
+          return nil unless status.success? && !stdout.strip.empty?
+
+          # Take the first match
+          number, _state = stdout.strip.split("\n").first.split("\t")
+          return nil unless number
+
+          { number: number.to_i, repo: github_repo }
+        rescue StandardError => e
+          LOG.warn "[Basecamp] Error resolving PR for card ##{card_number}: #{e.message}" if defined?(LOG)
+          nil
+        end
+
         def setup_routes(app)
           setup_webhook_route(app)
           setup_api_routes(app)

metadata

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