brainiac-fizzy 0.0.27 → 0.0.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dabc51c154f2caad4353e83a1c837a961bf1df27139ede86181929c8fa28290d
-  data.tar.gz: 6edde302d45dfe3628606cd005ca0ea6e3964d004bc6fe0c4c93be2d1590800d
+  metadata.gz: 93dfc73c8a3984f834883fbc59057446f220cf640ef14feecdc3882eab0f5e79
+  data.tar.gz: 16dccf767e981ab8b7ec4f4c9ad570a6af713fe9deb410f0e3163f8745def891
 SHA512:
-  metadata.gz: ac4ce9b1192051ce0d748d13c1ecdc834935bc503513fb101486460cfc478046749475d5eaa7cfff32252ba34e2be65efad10f3a9aecd6d8b1bdf2aa0c10cd33
-  data.tar.gz: 24afb9c9f9af9f481be0df59afeb94546e49546033d40190cee639fb17989b90dc5011f1c7d911daea9d21be1d7c3707e4180cb4be719220aad029a91c4268d1
+  metadata.gz: dfabf4b7239f9fa9181fb327c24660e7c39c0a1558151362330ff67c8c334ba9565239e5da35c1335c67bd5dfdd246cacf8295509e6e61c86b9afb0f2f6be43d
+  data.tar.gz: ebafbeceb274b07e70f23f69d8b7123af573d646e58d92eb756b693bf2cf4d87a12ab7fc79ddca3ced785c54d3beca9c8c602a4c655d0158067cc952d441a90f

data/README.md

@@ -37,6 +37,8 @@ Fizzy configuration lives in `~/.brainiac/fizzy.json` (same as before):
     { "id": "user-id-1", "name": "Andy", "human": true },
     { "id": "agent-id-1", "name": "Galen", "human": false }
   ],
+  "uat_agent": false,
+  "uat_agent_tag": "uat",
   "boards": {
     "development": {
       "board_id": "your-board-id",
@@ -51,6 +53,25 @@ Fizzy configuration lives in `~/.brainiac/fizzy.json` (same as before):
 }
 ```
 
+### UAT agent (`uat_agent`)
+
+When a PR is merged and its card moves to the UAT column, Brainiac can dispatch
+an LLM agent to write manual testing steps as a card comment. This spends tokens
+on every merge, so it's **disabled by default**. Set `"uat_agent": true` at the
+top level of `fizzy.json` to opt back in globally. The card still moves to UAT
+and gets the PR-merged comment either way — only the agent dispatch is gated.
+
+**Per-card opt-in:** Even with `uat_agent` off globally, you can trigger the UAT
+agent for a single card by adding the `uat` tag to it. When the card's PR merges,
+Brainiac fetches the card's live tags and dispatches the UAT agent if the tag is
+present. Customize the tag name with `"uat_agent_tag": "your-tag"`, or set it to
+`false`/`null` to disable per-card overrides entirely. This gives you three
+states:
+
+- `uat_agent: true` — dispatch on every merge
+- `uat_agent: false` (default) + `uat` tag on a card — dispatch for that card only
+- `uat_agent: false` + no tag — never dispatch (pure bookkeeping, zero tokens)
+
 ## What This Plugin Handles
 
 | Event | Action |

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

@@ -82,6 +82,26 @@ module Brainiac
             nil
           end
 
+          # Whether to dispatch an LLM agent to write UAT testing steps when a
+          # PR is merged and the card moves to UAT. Disabled by default to save
+          # tokens — set "uat_agent": true in ~/.brainiac/fizzy.json to enable
+          # globally. Individual cards can still opt in via the UAT tag even when
+          # this is false (see #uat_agent_tag).
+          def uat_agent_enabled?
+            @config.fetch("uat_agent", false) == true
+          end
+
+          # The card tag that opts a single card into UAT agent dispatch even
+          # when uat_agent is globally disabled. Defaults to "uat". Set
+          # "uat_agent_tag": "some-tag" in fizzy.json to customize, or false/null
+          # to disable per-card overrides entirely.
+          def uat_agent_tag
+            value = @config.fetch("uat_agent_tag", "uat")
+            return nil if value == false || value.nil? || value.to_s.strip.empty?
+
+            value.to_s
+          end
+
           def authorized?(payload)
             creator_id = payload.dig("creator", "id")
             @authorized_user_ids.include?(creator_id)

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

@@ -274,3 +274,112 @@ def resolve_deployment_url(env_config, card_tags)
   end
   env_config["url"]
 end
+
+# Resolve the live ephemeral deployment URL for a given card number.
+# Returns { env:, url: } for the environment currently occupied by this card,
+# or nil if the card isn't deployed anywhere (or deployments aren't configured).
+#
+# Resolution order (live state is the source of truth):
+#   1. A tracked dev environment (dev01/dev02...) occupied by this card, from
+#      deployment_state.json.
+#   2. The card's ephemeral Belt environment (fizzy-<card>), from
+#      ephemeral_envs.json, with the public URL derived from its terraform.tfvars.
+def deployment_url_for_card(card_number)
+  return nil unless card_number
+
+  tracked_deployment_for_card(card_number) || ephemeral_deployment_for_card(card_number)
+rescue StandardError => e
+  LOG.warn "[Fizzy:Deploy] Could not resolve deployment URL for card ##{card_number}: #{e.message}" if defined?(LOG)
+  nil
+end
+
+# A tracked dev environment (dev01/dev02...) currently occupied by this card.
+def tracked_deployment_for_card(card_number)
+  return nil unless defined?(DEPLOYMENTS_CONFIG)
+
+  config = DEPLOYMENTS_CONFIG["environments"] || {}
+  state = load_deployment_state
+
+  env_key, info = state.find do |key, v|
+    v.is_a?(Hash) && v["card_number"].to_s == card_number.to_s && v["status"] == "occupied" && config.key?(key)
+  end
+  return nil unless env_key
+
+  url = resolve_deployment_url(config[env_key], info["card_tags"])
+  return nil unless url
+
+  { env: env_key, url: url }
+end
+
+EPHEMERAL_ENVS_FILE = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+
+# The active ephemeral Belt environment (fizzy-<card>) for this card, if any.
+# The public URL is derived from the env's terraform.tfvars in its worktree,
+# following the Belt frontend_urls convention.
+def ephemeral_deployment_for_card(card_number)
+  info = active_ephemeral_env_info(card_number)
+  return nil unless info
+
+  worktree = info["worktree"]
+  env_name = "fizzy-#{card_number}"
+  return nil unless worktree
+
+  tfvars = File.join(worktree, "infrastructure", env_name, "terraform.tfvars")
+  return nil unless File.exist?(tfvars)
+
+  url = ephemeral_url_from_tfvars(tfvars)
+  return nil unless url
+
+  { env: env_name, url: url }
+end
+
+# Look up the active ephemeral env metadata for a card from ephemeral_envs.json.
+def active_ephemeral_env_info(card_number)
+  return nil unless File.exist?(EPHEMERAL_ENVS_FILE)
+
+  state = JSON.parse(File.read(EPHEMERAL_ENVS_FILE))
+  info = state["fizzy-#{card_number}"]
+  return nil unless info.is_a?(Hash) && info["status"] == "active"
+
+  info
+rescue JSON::ParserError
+  nil
+end
+
+# Derive the public URL from a Belt 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 ephemeral_url_from_tfvars(tfvars_path)
+  vars = parse_tfvars(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_tfvars(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

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

@@ -72,9 +72,14 @@ module Brainiac
             env = Helpers.fizzy_env_for(agent_name)
 
             pr_url = Helpers.send(:detect_pr_url, branch, project_config)
+            deployment = respond_to?(:deployment_url_for_card, true) ? deployment_url_for_card(card_number) : nil
             body = "<p>✅ Work completed on this card.</p>"
-            body += "<p><a href=\"#{pr_url}\">View PR</a></p>" if pr_url
             body += "<p><strong>Branch:</strong> <code>#{branch}</code></p>"
+            body += "<p><strong>PR:</strong> <a href=\"#{pr_url}\">#{pr_url}</a></p>" if pr_url
+            if deployment
+              body += "<p><strong>Deployment (#{deployment[:env]}):</strong> " \
+                      "<a href=\"#{deployment[:url]}\">#{deployment[:url]}</a></p>"
+            end
 
             run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", body,
                     chdir: repo_path, env: env)

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

@@ -171,16 +171,13 @@ module Brainiac
             last_agent_comment = agent_comments.last
             return false unless last_agent_comment
 
-            # Append footer if applicable
+            # Backup: ensure the comment surfaces branch, PR link, and live deployment link.
+            # Whatever the agent already included is left alone; we only append what's missing.
             body = last_agent_comment.dig("body", "html") || ""
-            unless footer_already_present?(body)
-              branch = detect_branch_from_comment(body, card_number)
-              if branch
-                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)
-              end
+            updated_body = ensure_reference_footer(body, card_number, project_config)
+            if updated_body != body
+              run_cmd("fizzy", "comment", "update", last_agent_comment["id"], "--card", card_number.to_s,
+                      "--body", updated_body, chdir: repo_path, env: env)
             end
 
             true
@@ -189,6 +186,42 @@ module Brainiac
             false
           end
 
+          # Build the reference footer (Branch / PR / Deployment) and append any pieces
+          # that the agent's comment body doesn't already contain. Returns the (possibly
+          # unchanged) body. Detection is deliberately lenient — if the branch name, PR
+          # URL, or deployment URL already appears anywhere in the body, it's not re-added.
+          def ensure_reference_footer(body, card_number, project_config)
+            branch = detect_branch_from_comment(body, card_number)
+            return body unless branch
+
+            pr_url = detect_pr_url(branch, project_config)
+            deployment = detect_deployment(card_number)
+
+            footer_lines = []
+            footer_lines << "<strong>Branch:</strong> <code>#{branch}</code>" unless body.include?(branch)
+            if pr_url && !body.include?(pr_url) && !body.include?("github.com/#{project_config["github_repo"]}/pull")
+              footer_lines << "<strong>PR:</strong> <a href=\"#{pr_url}\">#{pr_url}</a>"
+            end
+            if deployment && !body.include?(deployment[:url])
+              footer_lines << "<strong>Deployment (#{deployment[:env]}):</strong> " \
+                              "<a href=\"#{deployment[:url]}\">#{deployment[:url]}</a>"
+            end
+
+            return body if footer_lines.empty?
+
+            "#{body}<p><em>#{footer_lines.join(" &middot; ")}</em></p>"
+          end
+
+          # Resolve the live deployment for a card as { env:, url: }, or nil.
+          # Reads live deployment state (tracked dev envs from deployment_state.json,
+          # and the card's ephemeral Belt env from ephemeral_envs.json) — the actual
+          # source of truth for which environment a card currently occupies.
+          def detect_deployment(card_number)
+            return nil unless respond_to?(:deployment_url_for_card, true)
+
+            deployment_url_for_card(card_number)
+          end
+
           def ensure_fizzy_yaml!(chdir, project_config)
             fizzy_yaml_dest = File.join(chdir, ".fizzy.yaml")
             return if File.exist?(fizzy_yaml_dest)
@@ -345,33 +378,6 @@ module Brainiac
           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/hooks.rb

@@ -134,36 +134,7 @@ module Brainiac
           # PR merged — post comment on Fizzy card, move to UAT, dispatch UAT agent
           def register_pr_merged
             Brainiac.on(:pr_merged) do |ctx|
-              card_number = ctx[:card_number]
-              next unless card_number
-
-              card_info = ctx[:card_info]
-              card_agent = card_info["agent"]
-              env = Helpers.fizzy_env_for(card_agent)
-              repo_path = ctx[:repo_path]
-              board_key = card_info.dig("sources", "fizzy", "board_key") || Config.board_key_for_project(ctx[:project_config])
-
-              # Post PR link comment
-              pr_url = ctx[:pr_url]
-              pr_title = ctx[:pr_title]
-              branch = ctx[:branch]
-              comment_body = "<p>PR merged into main: <a href=\"#{pr_url}\">#{pr_title}</a></p>" \
-                             "<p>Branch: <code>#{branch}</code></p>"
-              run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", comment_body,
-                      chdir: repo_path, env: env)
-
-              # Move card to UAT
-              Helpers.move_card_to_column(card_number, "uat",
-                                          project_config: ctx[:project_config],
-                                          agent_name: card_agent,
-                                          board_key: board_key)
-              record_self_move(card_number)
-
-              # Clear deployment tracking
-              clear_deployment_for_card(card_number) if respond_to?(:clear_deployment_for_card)
-
-              # Dispatch UAT agent
-              dispatch_fizzy_uat_agent(ctx)
+              handle_pr_merged(ctx)
             rescue StandardError => e
               LOG.error "[Fizzy] Error in pr_merged hook: #{e.message}" if defined?(LOG)
             end
@@ -292,6 +263,75 @@ module Brainiac
 
           # --- Private helpers ---
 
+          # Body of the :pr_merged hook. Posts the PR link comment, moves the
+          # card to UAT, clears deployment tracking, and dispatches the UAT
+          # agent when enabled. Extracted from the hook block to keep the
+          # registration method within complexity limits.
+          def handle_pr_merged(ctx)
+            card_number = ctx[:card_number]
+            return unless card_number
+
+            card_info = ctx[:card_info]
+            card_agent = card_info["agent"]
+            env = Helpers.fizzy_env_for(card_agent)
+            repo_path = ctx[:repo_path]
+            board_key = card_info.dig("sources", "fizzy", "board_key") || Config.board_key_for_project(ctx[:project_config])
+
+            # Post PR link comment
+            comment_body = "<p>PR merged into main: <a href=\"#{ctx[:pr_url]}\">#{ctx[:pr_title]}</a></p>" \
+                           "<p>Branch: <code>#{ctx[:branch]}</code></p>"
+            run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", comment_body,
+                    chdir: repo_path, env: env)
+
+            # Move card to UAT
+            Helpers.move_card_to_column(card_number, "uat",
+                                        project_config: ctx[:project_config],
+                                        agent_name: card_agent,
+                                        board_key: board_key)
+            record_self_move(card_number)
+
+            # Clear deployment tracking
+            clear_deployment_for_card(card_number) if respond_to?(:clear_deployment_for_card)
+
+            # Dispatch UAT agent — off by default to save tokens. Globally
+            # enabled via "uat_agent": true, or per-card via the UAT tag
+            # (default "uat") even when the global flag is off.
+            if uat_agent_dispatch?(card_number, repo_path: repo_path, env: env)
+              dispatch_fizzy_uat_agent(ctx)
+            else
+              log_uat_dispatch_skipped(card_number)
+            end
+          end
+
+          # Log that UAT dispatch was skipped for a card (global flag off, no tag).
+          def log_uat_dispatch_skipped(card_number)
+            return unless defined?(LOG)
+
+            LOG.info "[Fizzy] UAT agent disabled (set \"uat_agent\": true in fizzy.json, or add the " \
+                     "\"#{Config.uat_agent_tag}\" tag to this card) — skipping dispatch for card ##{card_number}"
+          end
+
+          # Decide whether to dispatch the UAT agent for a merged card.
+          # True when globally enabled, OR when the card carries the configured
+          # UAT tag (per-card opt-in). Card tags aren't in the pr_merged ctx, so
+          # we fetch them live — only when the global flag is off, to avoid an
+          # extra API call when it's already enabled.
+          def uat_agent_dispatch?(card_number, repo_path:, env: nil)
+            return true if Config.uat_agent_enabled?
+
+            tag = Config.uat_agent_tag
+            return false unless tag && card_number && repo_path
+
+            tags = Helpers.fetch_card_tags(card_number, repo_path: repo_path, env: env)
+            return false unless tags
+
+            has_tag = Helpers.card_has_tag?(tags, tag)
+            if has_tag && defined?(LOG)
+              LOG.info "[Fizzy] Card ##{card_number} has \"#{tag}\" tag — dispatching UAT agent despite global flag being off"
+            end
+            has_tag
+          end
+
           def dispatch_fizzy_uat_agent(ctx)
             card_number = ctx[:card_number]
             card_info = ctx[:card_info]

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

@@ -62,10 +62,19 @@ module Brainiac
           {{PR_TARGET_INSTRUCTION}}
 
           **Response destination: Post your response as a comment on Fizzy card #{{CARD_NUMBER}}.**
-          Your comment MUST include a concise summary of what you did, a PR link, and the branch name.
+          Your comment MUST include a concise summary of what you did.
 
-          **MANDATORY: Always include the branch name in your comment.** Use this format:
-          `<p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>`
+          **MANDATORY: Always end your comment with a References block containing all three of the following:**
+          - The branch name
+          - A link to the PR
+          - A link to the live deployed ephemeral environment (if this card was deployed — check the card's [deploy] tag / deployment; if not deployed, state "Not deployed")
+
+          Use this exact HTML format:
+          ```
+          <p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>
+          <p><strong>PR:</strong> <a href="PR_URL_HERE">PR_URL_HERE</a></p>
+          <p><strong>Deployment:</strong> <a href="DEPLOY_URL_HERE">DEPLOY_URL_HERE</a></p>
+          ```
         PROMPT
 
         FOLLOWUP_WORKTREE = <<~'PROMPT'
@@ -123,11 +132,19 @@ module Brainiac
           Read your memory file for this card and write a brief summary comment.
 
           **Response destination: Post your response as a comment on Fizzy card #{{CARD_NUMBER}}.**
-          Include what you did, any PR link, and the branch name.
-          Keep it concise — this is a summary, not a full report.
+          Include what you did. Keep it concise — this is a summary, not a full report.
 
-          **MANDATORY: Always include the branch name in your comment.** Use this format:
-          `<p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>`
+          **MANDATORY: Always end your comment with all three of the following:**
+          - The branch name
+          - A link to the PR
+          - A link to the live deployed ephemeral environment (or "Not deployed" if the card wasn't deployed)
+
+          Use this exact HTML format:
+          ```
+          <p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>
+          <p><strong>PR:</strong> <a href="PR_URL_HERE">PR_URL_HERE</a></p>
+          <p><strong>Deployment:</strong> <a href="DEPLOY_URL_HERE">DEPLOY_URL_HERE</a></p>
+          ```
         PROMPT
 
         UAT_TESTING = <<~'PROMPT'

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

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

data/lib/brainiac/plugins/fizzy.rb

@@ -3,7 +3,6 @@
 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.27
+  version: 0.0.29
 platform: ruby
 authors:
 - Andy Davis
@@ -92,7 +92,6 @@ 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

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

@@ -1,73 +0,0 @@
-# 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