brainiac-fizzy 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98a0dcf9fc45aff45ad0dd467090b4f7ef96e426ce2862fcf5b9251baf4fc519
-  data.tar.gz: eb2b8ec913902f3365efefa1424ae271f3e63f94161c0bbaddc116f9c0ec1bcb
+  metadata.gz: 58da7bc4b4b3365df978936518462a054cd9aa1f4b1715cfdb45c41820c10cac
+  data.tar.gz: e3b3c47d4bbc5f03e58d99fb5281fc67ababeebf299ed78d505cd831556e36f1
 SHA512:
-  metadata.gz: 065dd360d8c26815dc3122e652003c40296edd8fcd582ac9d23a8446b3e29bbcff7d2983b468ad4c395b5729d1ee309a26756af663291ea5385ba4325d7d885d
-  data.tar.gz: 969d24c897c660ef777576c258df0b26d9f86d478525306f53e5836bcb36716ad6b9b9d6133a465efce89a14c4fab51f5b46b3f44e2f563fdbf885d7caaccaad
+  metadata.gz: 0cd98dc6c45a30b806cb8da059fee1e8d49d36032fba262e0cbc9d5e82d563daa6f32bbd6b5419a3f7ae9b139ecc9613f07b93202edcb8dfb44f823e2b8867af
+  data.tar.gz: 7cd864aa4ab8b418052ce1c251b17f89bab7aa1fe2163efb6df3bab7df5629d57386180fe52f5d6d6983d2c9910fdd6a27fcc0bdf650e0e1186798b388cdec7f

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

@@ -50,6 +50,18 @@ def detect_planning_mode(text:, tags:, card_internal_id:, card_number:)
                                                          card_internal_id: card_internal_id, card_number: card_number)
 end
 
+def lookup_fizzy_card_info(card_internal_id)
+  Brainiac::Plugins::Fizzy::Helpers.lookup_fizzy_card_info(card_internal_id)
+end
+
+def update_fizzy_work_item(card_internal_id, updates)
+  Brainiac::Plugins::Fizzy::Helpers.update_fizzy_work_item(card_internal_id, updates)
+end
+
+def resolve_card_number(internal_id, repo_path:)
+  Brainiac::Plugins::Fizzy::Helpers.resolve_card_number(internal_id, repo_path: repo_path)
+end
+
 def verify_fizzy_signature!(request, payload_body, board_key: nil)
   Brainiac::Plugins::Fizzy::Helpers.verify_signature!(request, payload_body, board_key: board_key)
 end

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

@@ -46,11 +46,23 @@ def handle_card_assigned(payload)
   react_to_assignment(card_number, repo_path, assigned_agent)
   worktree_path = setup_assigned_worktree(repo_path, branch, card_internal_id, card_number, project_key, assigned_agent)
 
+  initial_cli = detect_cli_provider(tags: tags)
+  initial_model = detect_model(project_config, tags: tags)
+  initial_effort = detect_effort(project_config, tags: tags)
+
+  # Persist initial overrides from card tags to the work item
+  resolve_work_item_overrides(
+    branch: branch,
+    inline_cli_provider: initial_cli,
+    inline_model: initial_model,
+    inline_effort: initial_effort
+  )
+
   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,
-    agent_name: assigned_agent, model: detect_model(project_config, tags: tags),
-    effort: detect_effort(project_config, tags: tags), cli_provider_override: detect_cli_provider(tags: tags)
+    agent_name: assigned_agent, model: initial_model,
+    effort: initial_effort, cli_provider_override: initial_cli
   )
 end
 
@@ -103,12 +115,10 @@ def setup_assigned_worktree(repo_path, branch, card_internal_id, card_number, pr
   worktree_path = File.join(File.dirname(repo_path), "#{File.basename(repo_path)}--#{branch}")
   worktree_path = create_or_reuse_worktree(repo_path: repo_path, branch: branch, worktree_path: worktree_path)
 
-  map = load_work_item_map
-  map[card_internal_id] = {
-    "number" => card_number, "branch" => branch, "worktree" => worktree_path,
-    "project" => project_key, "agent" => agent_name
-  }
-  save_work_item_map(map)
+  register_work_item(
+    branch: branch, worktree: worktree_path, project: project_key, agent: agent_name,
+    source: :fizzy, source_data: { "card_internal_id" => card_internal_id, "card_number" => card_number }
+  )
   worktree_path
 end
 

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

@@ -41,11 +41,9 @@ def handle_comment(payload)
   agent_result = validate_agent_comment(creator_is_agent, is_api_sourced, creator_name, mentioned_agent, card_internal_id)
   return agent_result if agent_result
 
-  card_info = load_work_item_map[card_internal_id]
+  card_info = lookup_fizzy_card_info(card_internal_id)
   comment_id = eventable["id"]
 
-  return [200, { status: "ignored", reason: "not relevant" }.to_json] unless mentioned_agent || card_info
-
   project_config, project_key = resolve_fizzy_project(card_info, card_internal_id, eventable)
   return [200, { status: "ignored", reason: "no matching project" }.to_json] unless project_config
 
@@ -93,16 +91,39 @@ def build_comment_context(eventable:, plain_text:, tags:, card_internal_id:, car
   card_tags = eventable.dig("card", "tags") || []
   clean_text = tags[:clean_text]
 
+  inline_cli = detect_cli_provider(text: plain_text, tags: card_tags)
+  inline_model = detect_model(project_config, text: plain_text)
+  inline_effort = detect_effort(project_config, tags: card_tags, text: plain_text)
+
+  # Resolve overrides against the work item — merges stored overrides with inline tags
+  # and persists any new inline tags for future dispatches.
+  branch = card_info["branch"] if card_info.is_a?(Hash)
+  if branch
+    resolved = resolve_work_item_overrides(
+      branch: branch,
+      inline_cli_provider: inline_cli,
+      inline_model: inline_model,
+      inline_effort: inline_effort
+    )
+    effective_cli = resolved[:cli_provider]
+    effective_model = resolved[:model]
+    effective_effort = resolved[:effort]
+  else
+    effective_cli = inline_cli
+    effective_model = inline_model
+    effective_effort = inline_effort
+  end
+
   CommentContext.new(
     eventable: eventable, plain_text: clean_text, card_internal_id: card_internal_id,
     card_info: card_info, comment_id: comment_id, creator_name: creator_name,
     creator_is_agent: creator_is_agent, mentioned_agent: mentioned_agent,
     agent_name: agent_name, is_cross_agent_mention: is_cross_agent_mention,
     project_config: project_config, project_key: project_key,
-    model: detect_model(project_config, text: plain_text),
-    effort: detect_effort(project_config, tags: card_tags, text: plain_text),
+    model: effective_model,
+    effort: effective_effort,
     deploy_intent: deploy_intent,
-    cli_provider_override: detect_cli_provider(text: plain_text, tags: card_tags),
+    cli_provider_override: effective_cli,
     card_tags: card_tags,
     worktree_override: resolve_worktree_override(tags, project_config),
     comment_vars: {
@@ -158,7 +179,7 @@ end
 def validate_agent_comment(creator_is_agent, is_api_sourced, creator_name, mentioned_agent, card_internal_id)
   return nil unless creator_is_agent || is_api_sourced
 
-  card_info = load_work_item_map[card_internal_id]
+  card_info = lookup_fizzy_card_info(card_internal_id)
   card_assigned_agent = card_info&.dig("agent")
 
   agent_is_assigned = card_assigned_agent && card_assigned_agent.downcase == (creator_name || "").downcase
@@ -207,7 +228,8 @@ end
 
 def handle_cancel_command(eventable, card_internal_id)
   killed = 0
-  card_number_for_cancel = load_work_item_map.dig(card_internal_id, "number")
+  cancel_card_info = lookup_fizzy_card_info(card_internal_id)
+  card_number_for_cancel = cancel_card_info&.dig("number")
   prefixes = ["card-#{card_internal_id}"]
   prefixes << "card-#{card_number_for_cancel}" if card_number_for_cancel
 
@@ -229,9 +251,8 @@ def handle_cancel_command(eventable, card_internal_id)
   end
 
   comment_id_for_cancel = eventable["id"]
-  card_info_for_cancel = load_work_item_map[card_internal_id]
-  if card_info_for_cancel && card_number_for_cancel && comment_id_for_cancel
-    repo = (card_info_for_cancel["project"] && PROJECTS.dig(card_info_for_cancel["project"], "repo_path")) ||
+  if cancel_card_info && card_number_for_cancel && comment_id_for_cancel
+    repo = (cancel_card_info["project"] && PROJECTS.dig(cancel_card_info["project"], "repo_path")) ||
            DEFAULT_PROJECT["repo_path"]
     Thread.new do
       run_cmd("fizzy", "reaction", "create", "--card", card_number_for_cancel.to_s,
@@ -257,9 +278,7 @@ def resolve_fizzy_project(card_info, card_internal_id, eventable)
       if project_result
         project_key, project_config = project_result
         card_info["project"] = project_key
-        map = load_work_item_map
-        map[card_internal_id] = card_info
-        save_work_item_map(map)
+        update_fizzy_work_item(card_internal_id, "project" => project_key)
         LOG.info "Backfilled project '#{project_key}' for card #{card_internal_id} in card map"
       else
         LOG.warn "No project found for card #{card_internal_id}"
@@ -305,21 +324,23 @@ def resolve_assigned_agent(card_info, card_internal_id, eventable, project_confi
   card_assignees = eventable.dig("card", "assignees") || []
   webhook_agent = card_assignees.map { |a| a["name"] }.find { |name| local_agent_names.include?(name) }
 
-  webhook_agent = resolve_agent_via_api(card_info, card_internal_id, project_config) if webhook_agent.nil? && project_config
+  webhook_agent = resolve_agent_via_api(card_info, card_internal_id, eventable, project_config) if webhook_agent.nil? && project_config
 
   return nil unless webhook_agent
 
-  map = load_work_item_map
-  map[card_internal_id] ||= {}
-  map[card_internal_id]["agent"] = webhook_agent
-  save_work_item_map(map)
+  card_number = eventable.dig("card", "number")
+  update_fizzy_work_item(card_internal_id, { "agent" => webhook_agent }.tap { |h| h["number"] = card_number if card_number })
   LOG.info "Backfilled agent '#{webhook_agent}' into card map for #{card_internal_id}"
   webhook_agent
 end
 
-def resolve_agent_via_api(card_info, card_internal_id, project_config)
-  api_card_number = card_info&.dig("number") || card_internal_id
-  return nil unless api_card_number
+def resolve_agent_via_api(card_info, card_internal_id, eventable, project_config)
+  api_card_number = card_info&.dig("number") || eventable.dig("card", "number")
+  api_card_number ||= resolve_card_number(card_internal_id, repo_path: project_config["repo_path"])
+  unless api_card_number
+    LOG.warn "Cannot resolve agent via API — no card number available (internal_id: #{card_internal_id})"
+    return nil
+  end
 
   output = run_cmd("fizzy", "card", "show", api_card_number.to_s,
                    chdir: project_config["repo_path"], env: default_fizzy_env)
@@ -435,7 +456,7 @@ def handle_new_mention(ctx)
   card_title = card_data["title"] || "exploration"
 
   if card_number.nil?
-    map_entry = load_work_item_map[ctx.card_internal_id]
+    map_entry = lookup_fizzy_card_info(ctx.card_internal_id)
     card_number = if map_entry && map_entry["number"]
                     map_entry["number"]
                   else
@@ -461,12 +482,10 @@ def setup_new_mention_worktree(ctx, card_number, card_title)
   repo_path = ctx.project_config["repo_path"]
   worktree_path, branch = resolve_or_create_worktree(ctx, card_number, card_title, repo_path)
 
-  map = load_work_item_map
-  map[ctx.card_internal_id] = {
-    "number" => card_number, "branch" => branch, "worktree" => worktree_path,
-    "project" => ctx.project_key, "agent" => ctx.agent_name
-  }
-  save_work_item_map(map)
+  register_work_item(
+    branch: branch, worktree: worktree_path, project: ctx.project_key, agent: ctx.agent_name,
+    source: :fizzy, source_data: { "card_internal_id" => ctx.card_internal_id, "card_number" => card_number }
+  )
 
   [worktree_path, branch]
 end
@@ -567,12 +586,7 @@ end
 
 def resolve_and_save_card_number(card_internal_id, project_config)
   card_number = resolve_card_number(card_internal_id, repo_path: project_config["repo_path"])
-  if card_number
-    map = load_work_item_map
-    map[card_internal_id] ||= {}
-    map[card_internal_id]["number"] = card_number
-    save_work_item_map(map)
-  end
+  update_fizzy_work_item(card_internal_id, "number" => card_number) if card_number
   card_number
 end
 
@@ -580,10 +594,7 @@ def find_and_save_worktree(card_internal_id, card_number, project_config)
   found = find_worktree_for_card(card_number, repo_path: project_config["repo_path"])
   return nil unless found
 
-  map = load_work_item_map
-  map[card_internal_id] ||= {}
-  map[card_internal_id].merge!("worktree" => found[:worktree], "branch" => found[:branch])
-  save_work_item_map(map)
+  update_fizzy_work_item(card_internal_id, "worktree" => found[:worktree], "branch" => found[:branch])
   LOG.info "Found worktree by card number scan: #{found[:worktree]}"
   found[:worktree]
 end
@@ -655,7 +666,7 @@ end
 
 def resolve_or_create_worktree(ctx, card_number, card_title, repo_path)
   # Check for existing worktree in card map or on disk
-  existing_map_entry = load_work_item_map[ctx.card_internal_id]
+  existing_map_entry = lookup_fizzy_card_info(ctx.card_internal_id)
   if existing_map_entry && existing_map_entry["branch"] && existing_map_entry["worktree"] &&
      File.directory?(existing_map_entry["worktree"])
     LOG.info "Reusing existing worktree from card map: #{existing_map_entry["worktree"]}"

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

@@ -7,7 +7,7 @@
 
 def handle_deploy_comment(eventable, env_key, card_internal_id)
   comment_id = eventable["id"]
-  card_info = load_card_map[card_internal_id]
+  card_info = lookup_fizzy_card_info(card_internal_id)
 
   # Validate environment exists
   deploy_config = DEPLOYMENTS_CONFIG["environments"] || {}
@@ -139,10 +139,9 @@ def clone_branch_for_deploy(eventable, card_internal_id, card_info)
   end
 
   # Update card map
-  map = load_card_map
-  map[card_internal_id] ||= {}
-  map[card_internal_id].merge!("number" => card_number, "branch" => branch, "worktree" => worktree_path, "project" => project_key)
-  save_card_map(map)
+  update_fizzy_work_item(card_internal_id,
+                         "number" => card_number, "branch" => branch,
+                         "worktree" => worktree_path, "project" => project_key)
 
   LOG.info "[Deploy] Cloned branch #{branch} into worktree #{worktree_path} for card ##{card_number}"
   { worktree: worktree_path, card_number: card_number }

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

@@ -168,6 +168,91 @@ module Brainiac
             { card_id: card_number || card_internal_id }
           end
 
+          # Look up a Fizzy card's work item info by its internal ID.
+          # Returns a hash with top-level "number", "agent", "branch", "worktree", "project"
+          # keys for backward compatibility with handler code, or nil if not found.
+          def lookup_fizzy_card_info(card_internal_id)
+            return nil unless card_internal_id
+
+            result = find_work_item_by_card(card_internal_id)
+            return nil unless result
+
+            _work_item_id, info = result
+            # Ensure "number" is at top level for fizzy handler compat
+            info["number"] ||= info.dig("sources", "fizzy", "card_number")
+            info
+          end
+
+          # Update or create a work item entry for a Fizzy card.
+          # Accepts a hash of fields to merge into the existing entry.
+          # Handles both new-format (wi-xxx keyed) and creates new entries properly.
+          def update_fizzy_work_item(card_internal_id, updates)
+            return unless card_internal_id
+
+            map = load_work_item_map
+            result = nil
+            work_item_id = nil
+
+            # Find existing entry by card internal ID
+            map.each do |wid, info|
+              next unless info.is_a?(Hash)
+
+              fizzy_source = info.dig("sources", "fizzy")
+              next unless fizzy_source && fizzy_source["card_internal_id"] == card_internal_id
+
+              work_item_id = wid
+              result = info
+              break
+            end
+
+            card_number = updates.delete("number")
+
+            if result
+              result["sources"]["fizzy"]["card_number"] = card_number if card_number
+              result.merge!(updates)
+              map[work_item_id] = result
+            else
+              new_id = generate_work_item_id(branch: updates["branch"], card_number: card_number)
+              map[new_id] = {
+                "id" => new_id,
+                "branch" => updates["branch"],
+                "worktree" => updates["worktree"],
+                "project" => updates["project"],
+                "agent" => updates["agent"],
+                "sources" => {
+                  "fizzy" => {
+                    "card_internal_id" => card_internal_id,
+                    "card_number" => card_number
+                  }.compact
+                }
+              }.compact.merge(updates.except("branch", "worktree", "project", "agent"))
+            end
+
+            save_work_item_map(map)
+          end
+
+          # Resolve a card number from an internal ID by querying the Fizzy API.
+          # Searches card lists to find the matching card.
+          def resolve_card_number(internal_id, repo_path:)
+            env = default_fizzy_env
+            base_cmd = %w[fizzy card list]
+            ["--all", "--all --indexed-by closed"].each do |flags|
+              cmd = base_cmd + flags.split
+              output = run_cmd(*cmd, chdir: repo_path, env: env)
+              data = JSON.parse(output)["data"] || []
+              match = data.find { |c| c["id"] == internal_id }
+              if match
+                LOG.info "Resolved card number #{match["number"]} for internal_id #{internal_id}" if defined?(LOG)
+                return match["number"]
+              end
+            rescue StandardError
+              next
+            end
+
+            LOG.warn "Could not resolve card number for internal_id #{internal_id}" if defined?(LOG)
+            nil
+          end
+
           private
 
           def detect_branch_from_comment(body, card_number)
@@ -175,9 +260,12 @@ module Brainiac
             match = body.match(%r{<code>(fizzy-#{card_number}-[^<]+)</code>})
             return match[1] if match
 
-            # Fall back to card map
+            # Fall back to card map — check both new and old format
             map = load_work_item_map
-            entry = map.values.find { |v| v["number"].to_s == card_number.to_s }
+            entry = map.values.find do |v|
+              v.dig("sources", "fizzy", "card_number").to_s == card_number.to_s ||
+                v["number"].to_s == card_number.to_s
+            end
             entry&.dig("branch")
           end
 

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

@@ -255,7 +255,10 @@ module Brainiac
               card_number = card["number"]
               next unless card_number
 
-              map_entry = map.values.find { |info| info["number"] == card_number }
+              map_entry = map.values.find do |info|
+                info.dig("sources", "fizzy", "card_number").to_s == card_number.to_s ||
+                  info["number"].to_s == card_number.to_s
+              end
               agent_name = map_entry["agent"] if map_entry
               env = Helpers.fizzy_env_for(agent_name || AI_AGENT_NAME)
 
@@ -267,8 +270,8 @@ module Brainiac
                                                        primary_worktree: map_entry&.dig("worktree"), primary_branch: map_entry&.dig("branch"))
 
               if map_entry
-                internal_id = map.key(map_entry)
-                map.delete(internal_id)
+                work_item_id = map.key(map_entry)
+                map.delete(work_item_id)
               end
 
               closed << { number: card_number, url: card["url"], title: card["title"] }

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.8"
+      VERSION = "0.0.10"
     end
   end
 end

metadata

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