brainiac-fizzy 0.0.25 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d280084c82934cffbe0868040f944eab1f244ccc10563db9b7bd8a338f86d175
-  data.tar.gz: 47343a66a5232ea0bdc3d5e0ad8244692e7b4a8ee22efc91656f0e06e6a00c8d
+  metadata.gz: 7b9d6e5b3e6e6ea9306dc6fd9ce800dffc01e46f99b05f2861e0acf096793fe5
+  data.tar.gz: ec15a0b6f7a498de7662b8bd662fb519ae45f8a14d66e5912cf6dd540cc3726b
 SHA512:
-  metadata.gz: f6c5ddfde5c2eaf03ad0ce86bd996f6d28d1662be8e486015b16edf6c9a158d91638db521ea6f8d269b795d5f64c590e22cc0905c5fcfda7cb9a68c7494ddfd2
-  data.tar.gz: 3371c4fd11abbcdbee4ca7d5b520b1bba0180ad1c61e4172ca77cc95820cef496fc24380a71c97eb0bbe9ce4e5e48fa6934224ad605f393a5db8afb2b6b04f25
+  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,18 @@ 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

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,
@@ -183,3 +187,136 @@ def dispatch_assigned_card(card_number:, card_internal_id:, title:, tags:, branc
 
   [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

@@ -60,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/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.25"
+      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.25
+  version: 0.0.26
 platform: ruby
 authors:
 - Andy Davis