brainiac-fizzy 0.0.25 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d280084c82934cffbe0868040f944eab1f244ccc10563db9b7bd8a338f86d175
-  data.tar.gz: 47343a66a5232ea0bdc3d5e0ad8244692e7b4a8ee22efc91656f0e06e6a00c8d
+  metadata.gz: dabc51c154f2caad4353e83a1c837a961bf1df27139ede86181929c8fa28290d
+  data.tar.gz: 6edde302d45dfe3628606cd005ca0ea6e3964d004bc6fe0c4c93be2d1590800d
 SHA512:
-  metadata.gz: f6c5ddfde5c2eaf03ad0ce86bd996f6d28d1662be8e486015b16edf6c9a158d91638db521ea6f8d269b795d5f64c590e22cc0905c5fcfda7cb9a68c7494ddfd2
-  data.tar.gz: 3371c4fd11abbcdbee4ca7d5b520b1bba0180ad1c61e4172ca77cc95820cef496fc24380a71c97eb0bbe9ce4e5e48fa6934224ad605f393a5db8afb2b6b04f25
+  metadata.gz: ac4ce9b1192051ce0d748d13c1ecdc834935bc503513fb101486460cfc478046749475d5eaa7cfff32252ba34e2be65efad10f3a9aecd6d8b1bdf2aa0c10cd33
+  data.tar.gz: 24afb9c9f9af9f481be0df59afeb94546e49546033d40190cee639fb17989b90dc5011f1c7d911daea9d21be1d7c3707e4180cb4be719220aad029a91c4268d1

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/env_url.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Fizzy
+      # Derives the public URL of an ephemeral Belt environment from its
+      # terraform.tfvars. Kept separate from Helpers so the pure URL/HCL logic
+      # stays small and independently testable.
+      module EnvUrl
+        module_function
+
+        # URL of the ephemeral Belt environment for a card, if one is active.
+        # The env name is `fizzy-<card_number>`; the public URL is derived from the
+        # env's terraform.tfvars, matching the frontend_urls convention in the Belt
+        # infra module:
+        #   parent set -> https://<env>.<parent>.<domain>
+        #   prod       -> https://<domain>
+        #   otherwise  -> https://<env>.<domain>
+        def for_card(card_number)
+          return nil unless defined?(BeltConfig)
+
+          env_name = BeltConfig.ephemeral_env_for_card(card_number)
+          return nil unless BeltConfig.ephemeral_env?(env_name)
+
+          info = BeltConfig.respond_to?(:ephemeral_env_info) ? BeltConfig.ephemeral_env_info(env_name) : nil
+          worktree = info && info["worktree"]
+          return nil unless worktree
+
+          tfvars = File.join(worktree, "infrastructure", env_name.to_s, "terraform.tfvars")
+          return nil unless File.exist?(tfvars)
+
+          from_tfvars(tfvars)
+        rescue StandardError => e
+          LOG.warn "[Fizzy] Could not detect env URL for card ##{card_number}: #{e.message}" if defined?(LOG)
+          nil
+        end
+
+        def from_tfvars(tfvars_path)
+          vars = parse(File.read(tfvars_path))
+          domain = vars["domain"].to_s
+          return nil if domain.empty?
+
+          environment = vars["environment"].to_s
+          parent = vars["parent_environment"].to_s
+
+          host =
+            if !parent.empty?
+              "#{environment}.#{parent}.#{domain}"
+            elsif environment == "prod"
+              domain
+            else
+              "#{environment}.#{domain}"
+            end
+
+          "https://#{host}"
+        end
+
+        # Minimal HCL parser for `key = "value"` lines in terraform.tfvars.
+        def parse(contents)
+          vars = {}
+          contents.each_line do |line|
+            stripped = line.strip
+            next if stripped.empty? || stripped.start_with?("#")
+
+            match = stripped.match(/\A(\w+)\s*=\s*"([^"]*)"/)
+            vars[match[1]] = match[2] if match
+          end
+          vars
+        end
+      end
+    end
+  end
+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"]
@@ -142,14 +173,10 @@ module Brainiac
 
             # Append footer if applicable
             body = last_agent_comment.dig("body", "html") || ""
-            unless body.include?("<em>Branch:")
+            unless footer_already_present?(body)
               branch = detect_branch_from_comment(body, card_number)
               if branch
-                pr_url = detect_pr_url(branch, project_config)
-                footer = "<p><em>Branch: <code>#{branch}</code>"
-                footer += " | <a href=\"#{pr_url}\">PR</a>" if pr_url
-                footer += "</em></p>"
-
+                footer = build_comment_footer(branch, card_number, project_config)
                 updated_body = body + footer
                 run_cmd("fizzy", "comment", "update", last_agent_comment["id"], "--card", card_number.to_s,
                         "--body", updated_body, chdir: repo_path, env: env)
@@ -300,8 +327,51 @@ module Brainiac
             repo = project_config["github_repo"]
             return nil unless repo
 
+            # Prefer the existing open PR for this branch. `pull/new/<branch>` only
+            # opens the "create PR" page, which is wrong once a PR already exists.
+            existing = existing_pr_url(branch, repo, project_config["repo_path"])
+            return existing if existing
+
             "https://github.com/#{repo}/pull/new/#{branch}"
           end
+
+          # Look up the URL of an already-open PR for `branch` via the gh CLI.
+          # Returns nil if gh fails or no PR exists (caller falls back to new-PR link).
+          def existing_pr_url(branch, repo, repo_path)
+            output = run_cmd("gh", "pr", "view", branch, "--repo", repo, "--json", "url",
+                             "--jq", ".url", chdir: repo_path)
+            url = output.to_s.strip
+            url.empty? ? nil : url
+          rescue StandardError
+            nil
+          end
+
+          # True if the comment body already carries a "Branch:" footer/label, in
+          # either the footer format (`<em>Branch:`) or the agent-authored format
+          # (`<strong>Branch:</strong>`). Prevents appending a duplicate footer.
+          def footer_already_present?(body)
+            body.include?("<em>Branch:") ||
+              body.match?(%r{<strong>\s*Branch:\s*</strong>}i) ||
+              body.match?(/(^|>)\s*Branch:\s*</)
+          end
+
+          # Build the "<em>Branch: <code>...</code> | PR | Env</em>" footer.
+          # Includes the ephemeral env link when the card has an active env.
+          def build_comment_footer(branch, card_number, project_config)
+            pr_url = detect_pr_url(branch, project_config)
+            env_url = detect_env_url(card_number)
+
+            footer = "<p><em>Branch: <code>#{branch}</code>"
+            footer += " | <a href=\"#{pr_url}\">PR</a>" if pr_url
+            footer += " | <a href=\"#{env_url}\">Env</a>" if env_url
+            footer += "</em></p>"
+            footer
+          end
+
+          # URL of the ephemeral Belt environment for this card, if one is active.
+          def detect_env_url(card_number)
+            EnvUrl.for_card(card_number)
+          end
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.25"
+      VERSION = "0.0.27"
     end
   end
 end

data/lib/brainiac/plugins/fizzy.rb

@@ -3,6 +3,7 @@
 require_relative "fizzy/version"
 require_relative "fizzy/metadata"
 require_relative "fizzy/config"
+require_relative "fizzy/env_url"
 require_relative "fizzy/helpers"
 require_relative "fizzy/prompts"
 require_relative "fizzy/planning"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-fizzy
 version: !ruby/object:Gem::Version
-  version: 0.0.25
+  version: 0.0.27
 platform: ruby
 authors:
 - Andy Davis
@@ -92,6 +92,7 @@ files:
 - lib/brainiac/plugins/fizzy/cli.rb
 - lib/brainiac/plugins/fizzy/config.rb
 - lib/brainiac/plugins/fizzy/delegators.rb
+- lib/brainiac/plugins/fizzy/env_url.rb
 - lib/brainiac/plugins/fizzy/handlers/assignment.rb
 - lib/brainiac/plugins/fizzy/handlers/card_index.rb
 - lib/brainiac/plugins/fizzy/handlers/comments.rb