brainiac-fizzy 0.0.24 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5458df6821434350e3814c4002b36bf7c24449fec0375304004d96f34381c413
-  data.tar.gz: 6fe4ea5f51574cca99f6e90cada9480d6ff7a2c69008837f1e98259e1249abeb
+  metadata.gz: 7b9d6e5b3e6e6ea9306dc6fd9ce800dffc01e46f99b05f2861e0acf096793fe5
+  data.tar.gz: ec15a0b6f7a498de7662b8bd662fb519ae45f8a14d66e5912cf6dd540cc3726b
 SHA512:
-  metadata.gz: 6c9657c7470c20a0d288917a92d15d10823dd4ec3d113c7acf48f1b1263291106947ff0e8ecdbc675c49db1f928affc1050e9405820d11cd00e21aae329e4747
-  data.tar.gz: 0c03004274a798059eaa5f46025fba1e69e4b084ee99acf4a3185802a0eb6af58fed9ee23a87b7de74635c3080426a9a2aa226ae48646d9247b4afcdb8d3bec2
+  metadata.gz: 51284c7c4cca09f1bde28d3589fc7c17b29314e898f4de8bd7345fa1fd930baf6501ef47e42a241b40f17baede635780676154e7c6f456a70ea6f1d9902da59b
+  data.tar.gz: 868fc4f7e922d67138125385c486f87bc221766ddadf45e640ad880ee57914f04a772bdd3b688087c505a66cfa59f7643e1134f5731eb0ef67f3e42b6f80a700

data/lib/brainiac/plugins/fizzy/cli.rb

@@ -658,8 +658,73 @@ module Brainiac
       end
 
       # Subcommand names for bash completion.
-      def self.completions
-        %w[config status setup]
+      # When called with no args, returns top-level subcommands.
+      # When called with args (the words typed so far after the plugin name),
+      # returns context-sensitive completions for nested subcommands.
+      def self.completions(args = [])
+        return %w[board config setup status] if args.empty?
+
+        case args[0]
+        when "board"
+          board_completions(args[1..])
+        else
+          []
+        end
+      end
+
+      # Nested completions for `brainiac fizzy board ...`
+      def self.board_completions(args)
+        board_subcommands = %w[assign columns list ls setup webhook]
+        return board_subcommands if args.empty?
+
+        case args[0]
+        when "assign"
+          board_assign_completions(args[1..])
+        when "columns", "webhook"
+          board_key_completions(args[1..])
+        else
+          []
+        end
+      end
+
+      # Completions for `brainiac fizzy board assign <project> <board>`
+      def self.board_assign_completions(args)
+        case args.length
+        when 0
+          load_project_keys
+        when 1
+          load_board_keys
+        else
+          []
+        end
+      end
+
+      # Completions for commands that take a board key as next arg
+      def self.board_key_completions(args)
+        return load_board_keys if args.empty?
+
+        []
+      end
+
+      # Load board keys from fizzy.json for completion
+      def self.load_board_keys
+        config_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "fizzy.json")
+        return [] unless File.exist?(config_file)
+
+        config = JSON.parse(File.read(config_file))
+        (config["boards"] || {}).keys
+      rescue StandardError
+        []
+      end
+
+      # Load project keys from projects.json for completion
+      def self.load_project_keys
+        projects_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "projects.json")
+        return [] unless File.exist?(projects_file)
+
+        JSON.parse(File.read(projects_file)).keys
+      rescue StandardError
+        []
       end
 
       # Called by brainiac CLI after `agent create` — prompts for Fizzy user ID.

data/lib/brainiac/plugins/fizzy/delegators.rb

@@ -25,6 +25,22 @@ def prefetch_card_context(card_number, repo_path:, agent_name: nil)
   Brainiac::Plugins::Fizzy::Helpers.prefetch_card_context(card_number, repo_path: repo_path, agent_name: agent_name)
 end
 
+def tag_names(tags)
+  Brainiac::Plugins::Fizzy::Helpers.tag_names(tags)
+end
+
+def card_has_tag?(tags, name)
+  Brainiac::Plugins::Fizzy::Helpers.card_has_tag?(tags, name)
+end
+
+def fetch_card_tags(card_number, repo_path:, env: nil)
+  Brainiac::Plugins::Fizzy::Helpers.fetch_card_tags(card_number, repo_path: repo_path, env: env)
+end
+
+def resolve_github_agent_env(agent_name, github_repo)
+  Brainiac::Plugins::Fizzy::Helpers.resolve_github_agent_env(agent_name, github_repo)
+end
+
 def fetch_intent_context(card_number, repo_path:, agent_name: nil)
   Brainiac::Plugins::Fizzy::Helpers.fetch_intent_context(card_number, repo_path: repo_path, agent_name: agent_name)
 end

data/lib/brainiac/plugins/fizzy/handlers/assignment.rb

@@ -58,6 +58,10 @@ def handle_card_assigned(payload, board_key: nil)
     inline_effort: initial_effort
   )
 
+  maybe_create_ephemeral_belt_env(
+    worktree_path: worktree_path, card_number: card_number, project_key: project_key, tags: tags
+  )
+
   dispatch_assigned_card(
     card_number: card_number, card_internal_id: card_internal_id, title: title, tags: tags,
     branch: branch, worktree_path: worktree_path, project_config: project_config, project_key: project_key,
@@ -142,9 +146,7 @@ def dispatch_assigned_card(card_number:, card_internal_id:, title:, tags:, branc
   }
 
   # Resolve custom PR target (for epic branch workflows)
-  pr_target = if defined?(resolve_pr_target)
-                resolve_pr_target(repo_path: project_config["repo_path"], card_number: card_number, project_key: project_key)
-              end
+  pr_target = resolve_pr_target(repo_path: project_config["repo_path"], card_number: card_number, project_key: project_key)
   template_vars["PR_TARGET_INSTRUCTION"] = if pr_target
                                              "**IMPORTANT: Open the PR targeting the `#{pr_target}` branch " \
                                                "(not main).** Use: `gh pr create --base #{pr_target}`"
@@ -168,15 +170,153 @@ def dispatch_assigned_card(card_number:, card_internal_id:, title:, tags:, branc
            end
 
   card_key = "card-#{card_number}"
+
+  # Inject GitHub App token so agent's gh commands run as their bot identity
+  github_repo = project_config["github_repo"]
+  agent_github_env = resolve_github_agent_env(agent_name, github_repo)
+
   pid, log_file = run_agent(prompt,
                             project_config: project_config, chdir: worktree_path,
                             log_name: "assigned-#{card_number}", model: model, effort: effort,
                             agent_name: agent_name, card_number: card_number, source: :fizzy,
                             source_context: { card_number: card_number, board_key: board_key, dispatched_at: Time.now },
-                            cli_provider: cli_provider_override)
+                            cli_provider: cli_provider_override, env: agent_github_env)
   register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
 
   Thread.new { move_card_to_column(card_number, "right_now", project_config: project_config, agent_name: agent_name, board_key: board_key) }
 
   [200, { status: "processed", card: card_number, branch: branch, project: project_key, agent: agent_name }.to_json]
 end
+
+# Ensure an ephemeral Belt environment is configured in the worktree when the
+# card has a `deploy` tag. Fizzy has no tag-added webhook, so comment handlers
+# pass fetch_live_tags: true to read current tags from `fizzy card show`.
+#
+# `belt g environment` is synchronous so the worktree is configured before the
+# agent starts. The actual `belt deploy` runs in the background.
+def maybe_create_ephemeral_belt_env(worktree_path:, card_number:, project_key:, tags: nil,
+                                    repo_path: nil, agent_name: nil, fetch_live_tags: false)
+  unless defined?(BeltConfig) && defined?(BeltEnvironment)
+    LOG.debug "[EphemeralEnv] Belt utilities not available — skipping"
+    return
+  end
+
+  unless worktree_path && File.directory?(worktree_path)
+    LOG.debug "[EphemeralEnv] Worktree missing at #{worktree_path.inspect} — skipping"
+    return
+  end
+
+  unless belt_app_for_ephemeral?(worktree_path)
+    LOG.debug "[EphemeralEnv] #{project_key} is not a Belt app — skipping"
+    return
+  end
+
+  unless BeltConfig.ephemeral_deploys_enabled?
+    LOG.info "[EphemeralEnv] Ephemeral deploys disabled in basecamp.json"
+    return
+  end
+
+  resolved_tags = resolve_ephemeral_env_tags(
+    tags, card_number: card_number, repo_path: repo_path || worktree_path,
+          agent_name: agent_name, fetch_live_tags: fetch_live_tags
+  )
+  tag_list = tag_names(resolved_tags)
+  unless tag_list.include?("deploy")
+    LOG.debug "[EphemeralEnv] Card ##{card_number} tags=#{tag_list.inspect} — no deploy tag, skipping"
+    return
+  end
+
+  parent_env = BeltConfig.parent_env_for(project_key)
+  unless parent_env
+    LOG.info "[EphemeralEnv] Card ##{card_number} has deploy tag but no parent env configured for #{project_key}"
+    return
+  end
+
+  env_name = BeltConfig.ephemeral_env_for_card(card_number)
+  env_dir = File.join(worktree_path, "infrastructure", env_name.to_s)
+
+  if File.directory?(env_dir)
+    LOG.info "[EphemeralEnv] Card ##{card_number} has deploy tag; #{env_name} already configured at #{env_dir}"
+    track_ephemeral_env_if_needed(env_name, card_number, project_key, parent_env, worktree_path)
+    return
+  end
+
+  parent_dir = File.join(worktree_path, "infrastructure", parent_env.to_s)
+  unless File.directory?(parent_dir)
+    LOG.error "[EphemeralEnv] Parent env '#{parent_env}' not found at #{parent_dir}"
+    return
+  end
+
+  LOG.info "[EphemeralEnv] Card ##{card_number} has deploy tag; #{env_name} not in worktree — creating from '#{parent_env}'"
+  create_and_deploy_ephemeral_env(
+    worktree_path: worktree_path, env_name: env_name, parent_env: parent_env,
+    card_number: card_number, project_key: project_key
+  )
+rescue StandardError => e
+  LOG.error "[EphemeralEnv] Error creating ephemeral env: #{e.message}"
+end
+
+def ensure_ephemeral_env_for_comment(ctx, card_number, worktree)
+  return unless card_number && worktree && File.directory?(worktree)
+
+  maybe_create_ephemeral_belt_env(
+    worktree_path: worktree, card_number: card_number, project_key: ctx.project_key,
+    tags: ctx.card_tags, repo_path: ctx.project_config["repo_path"],
+    agent_name: ctx.agent_name, fetch_live_tags: true
+  )
+end
+
+def belt_app_for_ephemeral?(worktree_path)
+  return BeltEnvironment.belt_app?(worktree_path) if defined?(BeltEnvironment) && BeltEnvironment.respond_to?(:belt_app?)
+
+  %w[config/routes.rb config/routes.tf.rb infrastructure/routes.tf.rb].any? do |rel|
+    File.exist?(File.join(worktree_path, rel))
+  end
+end
+
+def resolve_ephemeral_env_tags(tags, card_number:, repo_path:, agent_name:, fetch_live_tags:)
+  return tags unless fetch_live_tags && card_number
+
+  live = fetch_card_tags(card_number, repo_path: repo_path, env: fizzy_env_for(agent_name || AI_AGENT_NAME))
+  if live
+    LOG.info "[EphemeralEnv] Card ##{card_number} live tags: #{tag_names(live).inspect}"
+    live
+  else
+    LOG.warn "[EphemeralEnv] Could not fetch live tags for card ##{card_number} — falling back to webhook tags #{tag_names(tags).inspect}"
+    tags
+  end
+end
+
+def track_ephemeral_env_if_needed(env_name, card_number, project_key, parent_env, worktree_path)
+  return if BeltConfig.ephemeral_env?(env_name)
+
+  BeltConfig.track_ephemeral_env(env_name,
+                                 "card_number" => card_number,
+                                 "project" => project_key,
+                                 "parent_env" => parent_env,
+                                 "worktree" => worktree_path)
+end
+
+def create_and_deploy_ephemeral_env(worktree_path:, env_name:, parent_env:, card_number:, project_key:)
+  success = BeltEnvironment.create_environment(
+    worktree: worktree_path, env_name: env_name, parent_env: parent_env
+  )
+  unless success
+    LOG.error "[EphemeralEnv] Failed to create environment '#{env_name}'"
+    return
+  end
+
+  BeltConfig.track_ephemeral_env(env_name,
+                                 "card_number" => card_number,
+                                 "project" => project_key,
+                                 "parent_env" => parent_env,
+                                 "worktree" => worktree_path)
+  LOG.info "[EphemeralEnv] Configured #{env_name} in worktree, deploying in background"
+
+  Thread.new do
+    frontend_only = BeltEnvironment.frontend_only_changes?(worktree: worktree_path)
+    BeltEnvironment.deploy(worktree: worktree_path, env_name: env_name, frontend_only: frontend_only)
+  rescue StandardError => e
+    LOG.error "[EphemeralEnv] Error deploying '#{env_name}': #{e.message}"
+  end
+end

data/lib/brainiac/plugins/fizzy/handlers/comments.rb

@@ -453,6 +453,10 @@ def handle_existing_card_comment(ctx)
   work_dir = worktree && File.directory?(worktree) ? worktree : ctx.project_config["repo_path"]
   card_key = "card-#{card_number || ctx.card_internal_id}"
 
+  # Fizzy has no tag-added webhook. On comment, fetch live tags and configure
+  # the Belt env in this worktree before dispatching (or queueing) the agent.
+  ensure_ephemeral_env_for_comment(ctx, card_number, worktree)
+
   # Session management (wait, supersede, or queue)
   queued = handle_session_conflict(ctx, card_key, card_number, work_dir)
   return queued if queued
@@ -491,6 +495,8 @@ def handle_new_mention(ctx)
   react_to_comment(card_number, ctx.comment_id, ctx.project_config, ctx.agent_name, "👀")
 
   worktree_path, branch = setup_new_mention_worktree(ctx, card_number, card_title)
+  ensure_ephemeral_env_for_comment(ctx, card_number, worktree_path)
+
   dispatch_new_mention(ctx, card_key: card_key, card_number: card_number,
                             card_title: card_title, branch: branch, worktree_path: worktree_path)
 end

data/lib/brainiac/plugins/fizzy/helpers.rb

@@ -33,6 +33,22 @@ module Brainiac
             fizzy_env_for(AI_AGENT_NAME)
           end
 
+          # Resolve GitHub App token for an agent so gh CLI runs as their bot identity.
+          # Uses brainiac-github's AppClient if available.
+          def resolve_github_agent_env(agent_name, github_repo)
+            return {} unless github_repo
+
+            if defined?(Brainiac::Plugins::Github::AppClient)
+              repo_owner = github_repo.split("/").first
+              token = Brainiac::Plugins::Github::AppClient.installation_token_for(agent_name, repo_owner: repo_owner)
+              return { "GH_TOKEN" => token } if token
+            end
+            {}
+          rescue StandardError => e
+            LOG.warn "[Fizzy] Could not resolve GitHub token for #{agent_name}: #{e.message}" if defined?(LOG)
+            {}
+          end
+
           def prefetch_card_context(card_number, repo_path:, agent_name: nil)
             env = fizzy_env_for(agent_name || AI_AGENT_NAME)
             card_details = fetch_card_details(card_number, repo_path: repo_path, env: env)
@@ -44,6 +60,37 @@ module Brainiac
             context
           end
 
+          # Normalize Fizzy tags from webhook hashes ({ "name" => "deploy" })
+          # or API strings ("deploy") into a lowercase name list.
+          def tag_names(tags)
+            Array(tags).filter_map do |tag|
+              name = tag.is_a?(Hash) ? (tag["name"] || tag[:name]) : tag
+              normalized = name.to_s.downcase
+              normalized unless normalized.empty?
+            end
+          end
+
+          def card_has_tag?(tags, name)
+            tag_names(tags).include?(name.to_s.downcase)
+          end
+
+          # Live tags from `fizzy card show`. Returns nil on failure so callers
+          # can fall back to webhook payload tags. Fizzy has no tag-added webhook;
+          # comment payloads may omit or stale-cache tags, so this is the source of truth.
+          def fetch_card_tags(card_number, repo_path:, env: nil)
+            return nil unless card_number && repo_path
+
+            env ||= default_fizzy_env
+            output = run_cmd("fizzy", "card", "show", card_number.to_s, chdir: repo_path, env: env)
+            card = JSON.parse(output)["data"]
+            return nil unless card
+
+            Array(card["tags"])
+          rescue StandardError => e
+            LOG.warn "[Fizzy] Could not fetch tags for card ##{card_number}: #{e.message}" if defined?(LOG)
+            nil
+          end
+
           def fetch_card_details(card_number, repo_path:, env:)
             output = run_cmd("fizzy", "card", "show", card_number.to_s, chdir: repo_path, env: env)
             card = JSON.parse(output)["data"]

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

@@ -167,17 +167,63 @@ module Brainiac
             rescue StandardError => e
               LOG.error "[Fizzy] Error in pr_merged hook: #{e.message}" if defined?(LOG)
             end
+
+            # Also listen for epic branch merges (from brainiac-basecamp)
+            # Move card to UAT when merged to any tracked branch
+            Brainiac.on(:pr_merged_to_branch) do |ctx|
+              card_number = ctx[:card_number]
+              next unless card_number
+
+              # Find the work item to get card info
+              branch = ctx[:branch]
+              work_item = find_work_item_by_branch(branch) if respond_to?(:find_work_item_by_branch, true)
+              work_item ||= Object.respond_to?(:find_work_item_by_branch, true) ? Object.send(:find_work_item_by_branch, branch) : nil
+
+              next unless work_item
+
+              _internal_id, card_info = work_item
+              card_agent = card_info["agent"]
+              board_key = card_info.dig("sources", "fizzy", "board_key")
+
+              # Load project config
+              project_key = card_info.dig("sources", "fizzy", "project") || card_info["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)) : {}
+              project_config = projects[project_key] || {}
+              repo_path = project_config["repo_path"]
+
+              next unless repo_path
+
+              # Move card to UAT (same as main merge)
+              LOG.info "[Fizzy] PR merged to #{ctx[:base_branch]} for card ##{card_number} — moving to UAT" if defined?(LOG)
+              Helpers.move_card_to_column(card_number, "uat",
+                                          project_config: project_config,
+                                          agent_name: card_agent,
+                                          board_key: board_key)
+              record_self_move(card_number)
+            rescue StandardError => e
+              LOG.error "[Fizzy] Error in pr_merged_to_branch hook: #{e.message}" if defined?(LOG)
+            end
           end
 
           # PR review received — post status comment on card
+          # Only for changes_requested reviews that need action, not for approvals or gate reviews
           def register_pr_review_received
             Brainiac.on(:pr_review_received) do |ctx|
               card_number = ctx[:card_number]
               next unless card_number
 
+              # Only post status for changes_requested — approvals don't need a Fizzy comment
+              review_state = ctx[:review_state]
+              next unless review_state == "changes_requested"
+
+              # Skip if this is a gate agent review (handled by brainiac-basecamp)
+              reviewer = ctx[:reviewer]
+              next if reviewer&.match?(/-(brainiac|bot)\b/i)
+
               Thread.new do
                 env = Helpers.fizzy_env_for(ctx[:agent_name])
-                status_comment = "<p>🔄 Code review received from @#{ctx[:reviewer]}. Updates in progress...</p>"
+                status_comment = "<p>🔄 Code review received from @#{reviewer}. Updates in progress...</p>"
                 run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", status_comment,
                         chdir: ctx[:repo_path], env: env)
               rescue StandardError => e

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.24"
+      VERSION = "0.0.26"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-fizzy
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.26
 platform: ruby
 authors:
 - Andy Davis