brainiac-fizzy 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0335c88018a40d0f597d0c7000d56e4fe047540a077e2d17b85b20819d730b1
-  data.tar.gz: c4b4262ef5b7d95687302edd2fb9864e93b3c4dd12f8eb0a8ea6a6dabd73536c
+  metadata.gz: 90ffad33201985cb5a94b3460fb635d254e806e435543eeb652b533ff59562a6
+  data.tar.gz: 209e7829523442c8ccc7e3a278454ddd008fd16df6f83495e1edd42c0ac9dada
 SHA512:
-  metadata.gz: ce588f2a8a5284d681d9dce3340aa90e8372039e60bbfe53a8cd4dbb1d1de6e28e37a86af7f075d5ed2e7618b52e7eec69de3ee100336f7679103a15acc6a0cd
-  data.tar.gz: 1d92e2d6d185dbd492826d1efe6d7a9c62ff2b5bda3e07a44b2ce4a803bc997ace21c77d03fe9f7c4d131b823e020d3dd2cd88e0f08e8e680d0c452a132bb494
+  metadata.gz: 207769fa7579c519e38ff9551a5b4fb0ff823c1cb88740b7bd3b7f1a459bfd8c7e9ea97e62fd7a6dbeb8a48218595d08143564be8cd577ff32a264be7a97d947
+  data.tar.gz: e5d52c3fc6dcf2427b70030fccdb3a9196b2c00ecf63b934710accbaa3cdfef16a7c98765afac1ae33435d86f58837371097b697e733d8484f8bdee6efdedef7

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

@@ -136,6 +136,14 @@ PROMPT_MENTION = Brainiac::Plugins::Fizzy::Prompts::MENTION
 PROMPT_CROSS_AGENT_REVIEW = Brainiac::Plugins::Fizzy::Prompts::CROSS_AGENT_REVIEW
 PROMPT_PLANNING_MODE = Brainiac::Plugins::Fizzy::Prompts::PLANNING_MODE
 
+# Default Fizzy board column IDs — used as fallback when board_key is nil or
+# the board config doesn't specify column mappings.
+DEFAULT_COLUMN_IDS = {
+  "right_now" => "03f5xa5q9fog9592pa1279dts",
+  "needs_review" => "03f5ykobhpsd78hbuvajtn8g8",
+  "uat" => "03fsmglsr6az06ppyotawsti8"
+}.freeze
+
 # Render planning mode prompt — identical to render_prompt but inserts the planning
 # instructions between PROMPT_CORE and the channel rules. This was originally defined
 # in brainiac core's planning.rb but belongs here after the fizzy extraction.
@@ -153,11 +161,9 @@ def render_planning_prompt(situation_template, vars = {}, brain_context: "", car
   result += plugin_prompt || CHANNEL_PROMPTS.fetch(channel, "")
   result += situation_template
 
-  # Pre-post comment check (same as render_prompt)
-  case channel
-  when :fizzy   then result += PROMPT_PRE_POST_CHECK_FIZZY
-  when :github  then result += PROMPT_PRE_POST_CHECK_GITHUB
-  end
+  # Pre-post comment check (same as render_prompt — use plugin-registered lookup)
+  plugin_pre_post = Brainiac.channel_pre_post_checks[channel]
+  result += plugin_pre_post if plugin_pre_post
 
   result += PROMPT_REFLECTION
 
@@ -174,12 +180,7 @@ def render_planning_prompt(situation_template, vars = {}, brain_context: "", car
     planning_vars[var_name] ||= (board_key && board_column_id(board_key, col_name)) || default_id
   end
 
-  # Touch memory file if CARD_ID is present — ensures file exists before agent tries to read it
-  if vars["CARD_ID"]
-    memory_file = File.join(planning_vars["MEMORY_DIR"], "card-#{vars["CARD_ID"]}.md")
-    FileUtils.mkdir_p(planning_vars["MEMORY_DIR"])
-    FileUtils.touch(memory_file)
-  end
+  ensure_memory_file_exists!(vars["CARD_ID"], planning_vars["MEMORY_DIR"])
 
   roster = agent_roster
   roster_lines = roster.map { |_key, display| "  - @#{display}" }.join("\n")
@@ -189,6 +190,15 @@ def render_planning_prompt(situation_template, vars = {}, brain_context: "", car
   result
 end
 
+# Ensure a card's memory file exists so the agent can read it without error.
+def ensure_memory_file_exists!(card_id, memory_dir)
+  return unless card_id
+
+  memory_file = File.join(memory_dir, "card-#{card_id}.md")
+  FileUtils.mkdir_p(memory_dir)
+  FileUtils.touch(memory_file)
+end
+
 # Config constants — handler files reference these as top-level constants.
 # These are evaluated after Config.load! has been called (during plugin register).
 # Use a delegating object so it always reflects current config state.

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

@@ -152,7 +152,7 @@ def dispatch_assigned_card(card_number:, card_internal_id:, title:, tags:, branc
                             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 },
+                            source_context: { card_number: card_number, dispatched_at: Time.now },
                             cli_provider: cli_provider_override)
   register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
 

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

@@ -78,9 +78,11 @@ def handle_comment(payload)
   directly_addressed = mentioned_agent || (card_info && card_info["agent"]&.downcase == agent_name.downcase)
   unless directly_addressed
     card_number_for_intent = card_info&.dig("number") || eventable.dig("card", "number")
-    intent_ctx = card_number_for_intent ? fetch_intent_context(card_number_for_intent, repo_path: project_config["repo_path"], agent_name: agent_name) : nil
+    intent_ctx = if card_number_for_intent
+                   fetch_intent_context(card_number_for_intent, repo_path: project_config["repo_path"], agent_name: agent_name)
+                 end
     if intent_skip?(ctx.plain_text, agent_name: agent_name, source: :fizzy,
-                    channel: "Fizzy card ##{card_number_for_intent || card_internal_id}", context: intent_ctx)
+                                    channel: "Fizzy card ##{card_number_for_intent || card_internal_id}", context: intent_ctx)
       return [200, { status: "intent_skip", agent: agent_name }.to_json]
     end
   end
@@ -406,7 +408,7 @@ def dispatch_cross_agent_review(ctx, card_key:, card_number:, card_assigned_agen
                             log_name: "review-#{ctx.agent_name.downcase}-#{card_number || ctx.card_internal_id}",
                             model: ctx.model, effort: ctx.effort, agent_name: ctx.agent_name,
                             card_number: card_number, comment_id: ctx.comment_id,
-                            source: :fizzy, source_context: { card_number: card_number },
+                            source: :fizzy, source_context: { card_number: card_number, dispatched_at: Time.now },
                             cli_provider: ctx.cli_provider_override)
   return [200, { status: "dispatch_failed", agent: ctx.agent_name, card: card_number }.to_json] unless pid
 
@@ -512,7 +514,7 @@ def dispatch_new_mention(ctx, card_key:, card_number:, card_title:, branch:, wor
                             model: ctx.model, effort: ctx.effort, agent_name: ctx.agent_name,
                             card_number: card_number, comment_id: ctx.comment_id,
                             source: :fizzy, cli_provider: ctx.cli_provider_override,
-                            source_context: { card_number: card_number })
+                            source_context: { card_number: card_number, dispatched_at: Time.now })
   return [200, { status: "dispatch_failed", agent: ctx.agent_name, card: card_number }.to_json] unless pid
 
   register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: ctx.agent_name)
@@ -532,9 +534,7 @@ def dispatch_followup_comment(ctx, card_key:, card_number:, work_dir:)
     agent_name: ctx.agent_name, chdir: work_dir
   )
 
-  if ctx.fresh && is_worktree
-    LOG.info "[Fizzy] [fresh] tag — forcing new session instead of resuming on card #{card_number || ctx.card_internal_id}"
-  end
+  LOG.info "[Fizzy] [fresh] — forcing new session instead of resuming on card #{card_number || ctx.card_internal_id}" if ctx.fresh && is_worktree
 
   prompt = if should_resume
              LOG.info "[Resume] Using lean prompt for follow-up on card #{card_number || ctx.card_internal_id}"
@@ -554,7 +554,7 @@ def dispatch_followup_comment(ctx, card_key:, card_number:, work_dir:)
                             source: :fizzy, cli_provider: ctx.cli_provider_override, resume: should_resume,
                             source_context: {
                               card_number: card_number, card_internal_id: ctx.card_internal_id,
-                              deploy_intent: ctx.deploy_intent
+                              deploy_intent: ctx.deploy_intent, dispatched_at: Time.now
                             })
   return [200, { status: "dispatch_failed", agent: ctx.agent_name, card: card_number }.to_json] unless pid
 

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Brainiac
+  module Plugins
+    module Fizzy
+      # Handles re-dispatch summarize sessions and fallback comment posting.
+      # Extracted from Hooks to keep module length manageable.
+      module Summarize
+        class << self
+          # Re-dispatch an agent to post a summary comment when it completed work
+          # but didn't comment on the card. Fires async with a 60s timeout.
+          # If this session also fails to comment, posts a minimal fallback.
+          def dispatch_summarize_session(ctx)
+            card_number = ctx[:card_number]
+            agent_name = ctx[:agent_name]
+            project_config = ctx[:project_config]
+            repo_path = project_config["repo_path"]
+            session_started_at = ctx[:source_context]&.dig(:dispatched_at)
+
+            map = load_work_item_map
+            work_item = find_work_item(map, card_number)
+
+            branch = work_item&.dig("branch") || "unknown"
+            card_title = work_item&.dig("title") || ctx[:source_context]&.dig(:card_title) || "untitled"
+            worktree_path = work_item&.dig("worktree") || repo_path
+
+            if defined?(LOG)
+              LOG.info "[Fizzy] Agent #{agent_name} completed card ##{card_number} without commenting — " \
+                       "dispatching summarize session"
+            end
+
+            pid, log_file = dispatch_summarize_agent(card_number, card_title, branch, agent_name,
+                                                     project_config, worktree_path)
+            register_session("card-#{card_number}-summarize", pid, log_file: log_file, agent_name: agent_name)
+
+            monitor_summarize_session(pid, card_number, agent_name, branch, repo_path, session_started_at,
+                                      project_config)
+          rescue StandardError => e
+            LOG.error "[Fizzy] Failed to dispatch summarize session for card ##{card_number}: #{e.message}" if defined?(LOG)
+            post_fallback_comment(card_number, work_item&.dig("branch") || "unknown", agent_name, project_config)
+          end
+
+          # Check if the agent posted a comment on the card since a given time.
+          # If no `since` is provided, checks for any agent comment (legacy behavior).
+          def agent_commented_on_card?(card_number, agent_name, repo_path:, since: nil)
+            env = Helpers.fizzy_env_for(agent_name)
+            output = run_cmd("fizzy", "comment", "list", "--card", card_number.to_s, chdir: repo_path, env: env)
+            comments = JSON.parse(output)["data"] || []
+            agent_display = agent_display_name(agent_name)
+
+            agent_comments = comments.select { |c| c["creator_name"]&.downcase == agent_display.downcase }
+            return agent_comments.any? unless since
+
+            agent_comments.any? do |c|
+              comment_time = c["created_at"] && Time.parse(c["created_at"])
+              comment_time && comment_time > since
+            end
+          rescue StandardError
+            false
+          end
+
+          # Post a minimal server-generated comment when all else fails.
+          def post_fallback_comment(card_number, branch, agent_name, project_config)
+            repo_path = project_config["repo_path"]
+            env = Helpers.fizzy_env_for(agent_name)
+
+            pr_url = Helpers.send(:detect_pr_url, branch, project_config)
+            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>"
+
+            run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", body,
+                    chdir: repo_path, env: env)
+            LOG.info "[Fizzy] Posted fallback comment on card ##{card_number}" if defined?(LOG)
+          rescue StandardError => e
+            LOG.error "[Fizzy] Failed to post fallback comment on card ##{card_number}: #{e.message}" if defined?(LOG)
+          end
+
+          private
+
+          def find_work_item(map, card_number)
+            map.values.find do |info|
+              info.is_a?(Hash) &&
+                (info.dig("sources", "fizzy", "card_number").to_s == card_number.to_s ||
+                 info["number"].to_s == card_number.to_s)
+            end
+          end
+
+          def dispatch_summarize_agent(card_number, card_title, branch, agent_name, project_config, worktree_path)
+            prompt = render_prompt(Prompts::SUMMARIZE_WORK,
+                                   { "CARD_NUMBER" => card_number, "CARD_TITLE" => card_title, "BRANCH" => branch },
+                                   brain_context: "", agent_name: agent_name, channel: :fizzy,
+                                   board_key: Config.board_key_for_project(project_config))
+
+            run_agent(prompt,
+                      project_config: project_config, chdir: worktree_path,
+                      log_name: "summarize-#{card_number}", agent_name: agent_name,
+                      source: :fizzy,
+                      source_context: { card_number: card_number, skip_summarize_redispatch: true },
+                      skip_column_move: true)
+          end
+
+          def monitor_summarize_session(pid, card_number, agent_name, branch, repo_path, session_started_at,
+                                        project_config)
+            Thread.new do
+              wait_for_process_or_timeout(pid, timeout: 60)
+              sleep 2 # Brief pause to let any comment propagate
+
+              unless agent_commented_on_card?(card_number, agent_name, repo_path: repo_path, since: session_started_at)
+                post_fallback_comment(card_number, branch, agent_name, project_config)
+              end
+            rescue Errno::ECHILD
+              # Process already reaped by session manager — check for comment
+              sleep 2
+              unless agent_commented_on_card?(card_number, agent_name, repo_path: repo_path, since: session_started_at)
+                post_fallback_comment(card_number, branch, agent_name, project_config)
+              end
+            rescue StandardError => e
+              LOG.error "[Fizzy] Summarize monitor error for card ##{card_number}: #{e.message}" if defined?(LOG)
+            end
+          end
+
+          def wait_for_process_or_timeout(pid, timeout: 60)
+            deadline = Time.now + timeout
+            loop do
+              result = Process.waitpid2(pid, Process::WNOHANG)
+              break if result
+
+              if Time.now > deadline
+                safe_kill(pid)
+                break
+              end
+              sleep 1
+            end
+          end
+
+          def safe_kill(pid)
+            Process.kill("TERM", pid)
+            Process.waitpid2(pid)
+          rescue Errno::ESRCH, Errno::ECHILD
+            # Process already gone
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Brainiac
   module Plugins
     module Fizzy
@@ -25,6 +27,7 @@ module Brainiac
           private
 
           # After an agent session completes — move card to needs_review, append footer
+          # If the agent didn't post a comment, re-dispatch for a summary.
           def register_agent_completed
             Brainiac.on(:agent_completed) do |ctx|
               next unless ctx[:source] == :fizzy
@@ -43,6 +46,16 @@ module Brainiac
                                                   project_config: ctx[:project_config],
                                                   agent_name: ctx[:agent_name])
 
+              # If the agent didn't post any comment during this session, re-dispatch to summarize from memory.
+              # Uses dispatched_at from source_context to only check for comments made during THIS session,
+              # not previous sessions on the same card.
+              if !ctx[:source_context]&.dig(:skip_summarize_redispatch) &&
+                 !agent_commented_on_card?(card_number, ctx[:agent_name],
+                                           repo_path: ctx[:project_config]["repo_path"],
+                                           since: ctx[:source_context]&.dig(:dispatched_at))
+                dispatch_summarize_session(ctx)
+              end
+
               # Planning mode finalization
               Planning.finalize_if_needed(ctx[:prompt_file], ctx[:agent_name], ctx[:project_config])
             end
@@ -240,13 +253,28 @@ module Brainiac
 
             pid, log_file = run_agent(prompt, project_config: project_config, chdir: repo_path,
                                               log_name: "uat-#{card_number}", agent_name: agent_name,
-                                              source: :fizzy, source_context: { card_number: card_number }, skip_column_move: true)
+                                              source: :fizzy,
+                                              source_context: { card_number: card_number, dispatched_at: Time.now },
+                                              skip_column_move: true)
             register_session("card-#{card_number}", pid, log_file: log_file, agent_name: agent_name)
             LOG.info "[Fizzy] Dispatched #{agent_name} for UAT on card ##{card_number}" if defined?(LOG)
           rescue StandardError => e
             LOG.error "[Fizzy] Failed to dispatch UAT agent: #{e.message}" if defined?(LOG)
           end
 
+          # Delegated to Summarize module for manageable file length.
+          def dispatch_summarize_session(ctx)
+            Summarize.dispatch_summarize_session(ctx)
+          end
+
+          def agent_commented_on_card?(card_number, agent_name, repo_path:, since: nil)
+            Summarize.agent_commented_on_card?(card_number, agent_name, repo_path: repo_path, since: since)
+          end
+
+          def post_fallback_comment(card_number, branch, agent_name, project_config)
+            Summarize.post_fallback_comment(card_number, branch, agent_name, project_config)
+          end
+
           def close_uat_cards(card_list, repo_path)
             closed = []
             map = load_work_item_map

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

@@ -55,7 +55,9 @@ module Brainiac
           You have been assigned Fizzy card #{{CARD_NUMBER}}: "{{CARD_TITLE}}".
           You are on branch "{{BRANCH}}" in a fresh worktree.
           Implement the task, commit, push, and open a PR (link back to Fizzy).
-          When you're done, post a comment on the card with a concise summary, PR link, and branch name.
+
+          **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.
 
           **MANDATORY: Always include the branch name in your comment.** Use this format:
           `<p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>`
@@ -111,6 +113,18 @@ module Brainiac
           **IMPORTANT: Do NOT @mention any other agents in your response.**
         PROMPT
 
+        SUMMARIZE_WORK = <<~'PROMPT'
+          You completed work on Fizzy card #{{CARD_NUMBER}} ("{{CARD_TITLE}}") but did not post a comment.
+          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.
+
+          **MANDATORY: Always include the branch name in your comment.** Use this format:
+          `<p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>`
+        PROMPT
+
         UAT_TESTING = <<~'PROMPT'
           PR for card #{{CARD_NUMBER}} ("{{CARD_TITLE}}") has been merged to main (PR #{{PR_NUMBER}}).
           Run any UAT testing steps defined in the card or acceptance criteria.

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Fizzy
-      VERSION = "0.0.12"
+      VERSION = "0.0.14"
     end
   end
 end

data/lib/brainiac/plugins/fizzy.rb

@@ -16,6 +16,7 @@ require_relative "fizzy/handlers/dedup"
 require_relative "fizzy/handlers/deploy"
 require_relative "fizzy/handlers/card_index"
 require_relative "fizzy/handlers/deployments"
+require_relative "fizzy/handlers/summarize"
 
 module Brainiac
   module Plugins

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-fizzy
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.14
 platform: ruby
 authors:
 - Andy Davis
@@ -98,6 +98,7 @@ files:
 - lib/brainiac/plugins/fizzy/handlers/dedup.rb
 - lib/brainiac/plugins/fizzy/handlers/deploy.rb
 - lib/brainiac/plugins/fizzy/handlers/deployments.rb
+- lib/brainiac/plugins/fizzy/handlers/summarize.rb
 - lib/brainiac/plugins/fizzy/helpers.rb
 - lib/brainiac/plugins/fizzy/hooks.rb
 - lib/brainiac/plugins/fizzy/metadata.rb