brainiac-fizzy 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58da7bc4b4b3365df978936518462a054cd9aa1f4b1715cfdb45c41820c10cac
-  data.tar.gz: e3b3c47d4bbc5f03e58d99fb5281fc67ababeebf299ed78d505cd831556e36f1
+  metadata.gz: 50d4aa7e239474b5b5046d0d0e98d4b5d1d5aa7faf5c8ff3fe4a69207fa477d2
+  data.tar.gz: a622fb92c3fef1d669ea2f910968c2295929a95bb32319541513a47ccdf7addc
 SHA512:
-  metadata.gz: 0cd98dc6c45a30b806cb8da059fee1e8d49d36032fba262e0cbc9d5e82d563daa6f32bbd6b5419a3f7ae9b139ecc9613f07b93202edcb8dfb44f823e2b8867af
-  data.tar.gz: 7cd864aa4ab8b418052ce1c251b17f89bab7aa1fe2163efb6df3bab7df5629d57386180fe52f5d6d6983d2c9910fdd6a27fcc0bdf650e0e1186798b388cdec7f
+  metadata.gz: 4a60a03934e9dd915781e244fb2c8b7d964c4be448d5be686a6f15ada36a6310768f9714c5968cf6dfd27328dc4c409aac59d3b154a32a661f1c40e48aa5373c
+  data.tar.gz: 965e79fa73936549609c41db26c35cb8bce914362df9a3a7dd5785f6e2edddce8c185e4435c946157fd8a9ef780291cadf5dee1deb104b5de5f67eea34a3633f

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

@@ -134,6 +134,59 @@ PROMPT_FOLLOWUP_WORKTREE = Brainiac::Plugins::Fizzy::Prompts::FOLLOWUP_WORKTREE
 PROMPT_FOLLOWUP_NO_WORKTREE = Brainiac::Plugins::Fizzy::Prompts::FOLLOWUP_NO_WORKTREE
 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
+
+# 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.
+def render_planning_prompt(situation_template, vars = {}, brain_context: "", card_context: "", agent_name: AI_AGENT_NAME,
+                           channel: :fizzy, board_key: nil)
+  plans_dir = Brainiac::Plugins::Fizzy::Planning::PLANS_DIR
+  plan_file = File.join(plans_dir, "card-#{vars["CARD_ID"]}-plan.md")
+
+  result = ""
+  result += "#{brain_context}\n" unless brain_context.empty?
+  result += card_context unless card_context.empty?
+  result += PROMPT_CORE
+  result += PROMPT_PLANNING_MODE.gsub("{{PLAN_FILE}}", plan_file)
+  result += CHANNEL_PROMPTS.fetch(channel, PROMPT_FIZZY_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
+
+  result += PROMPT_REFLECTION
+
+  planning_vars = vars.merge("PLAN_FILE" => plan_file)
+  planning_vars["KNOWLEDGE_DIR"] ||= KNOWLEDGE_DIR
+  planning_vars["MEMORY_DIR"] ||= memory_dir_for(agent_name)
+  planning_vars["PERSONA_DIR"] ||= persona_dir_for(agent_name)
+  planning_vars["PERSONA_COLLECTION"] ||= persona_collection_for(agent_name)
+  planning_vars["AGENT_NAME"] ||= agent_name
+
+  # Populate column IDs from board config, falling back to defaults
+  DEFAULT_COLUMN_IDS.each do |col_name, default_id|
+    var_name = "#{col_name.upcase}_COLUMN_ID"
+    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
+
+  roster = agent_roster
+  roster_lines = roster.map { |_key, display| "  - @#{display}" }.join("\n")
+  planning_vars["AGENT_ROSTER"] ||= roster_lines
+
+  planning_vars.each { |key, val| result.gsub!("{{#{key}}}", val.to_s) }
+  result
+end
 
 # Config constants — handler files reference these as top-level constants.
 # These are evaluated after Config.load! has been called (during plugin register).

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

@@ -17,7 +17,7 @@ CommentContext = Struct.new(
   :mentioned_agent, :agent_name, :is_cross_agent_mention,
   :project_config, :project_key, :card_number, :worktree,
   :model, :effort, :deploy_intent, :cli_provider_override,
-  :comment_vars, :card_tags, :worktree_override,
+  :comment_vars, :card_tags, :worktree_override, :fresh,
   keyword_init: true
 )
 
@@ -70,6 +70,21 @@ def handle_comment(payload)
     project_config: project_config, project_key: project_key
   )
 
+  # --- Intent gate (mirrors brainiac-discord pattern) ---
+  # "Directly addressed" for Fizzy: agent is assigned to the card OR explicitly @mentioned.
+  # All current dispatch paths satisfy one of these, so intent is always bypassed today.
+  # This infrastructure supports future scenarios where agents observe cards they aren't
+  # assigned to or mentioned on (ambient watchers).
+  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
+    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)
+      return [200, { status: "intent_skip", agent: agent_name }.to_json]
+    end
+  end
+
   # --- Route to appropriate sub-handler ---
   if is_cross_agent_mention
     handle_cross_agent_mention(ctx)
@@ -126,6 +141,7 @@ def build_comment_context(eventable:, plain_text:, tags:, card_internal_id:, car
     cli_provider_override: effective_cli,
     card_tags: card_tags,
     worktree_override: resolve_worktree_override(tags, project_config),
+    fresh: tags[:fresh],
     comment_vars: {
       "COMMENT_CREATOR" => creator_name || "Unknown",
       "COMMENT_ID" => comment_id.to_s,
@@ -385,17 +401,14 @@ def dispatch_cross_agent_review(ctx, card_key:, card_number:, card_assigned_agen
   review_worktree_path, review_branch = setup_cross_agent_worktree(ctx, card_number)
   prompt = build_cross_agent_prompt(ctx, card_number, card_assigned_agent, review_worktree_path, review_branch)
 
-  intent_ctx = fetch_intent_context(card_number, repo_path: ctx.project_config["repo_path"], agent_name: ctx.agent_name)
   pid, log_file = run_agent(prompt,
                             project_config: ctx.project_config, chdir: review_worktree_path,
                             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 },
-                            cli_provider: ctx.cli_provider_override,
-                            message: ctx.plain_text, channel: "Fizzy comment",
-                            context: intent_ctx)
-  return [200, { status: "intent_skip", agent: ctx.agent_name, card: card_number }.to_json] unless pid
+                            cli_provider: ctx.cli_provider_override)
+  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)
 
@@ -493,17 +506,14 @@ end
 def dispatch_new_mention(ctx, card_key:, card_number:, card_title:, branch:, worktree_path:)
   prompt = build_mention_prompt(ctx, card_number, card_title, branch, worktree_path)
 
-  intent_ctx = fetch_intent_context(card_number, repo_path: ctx.project_config["repo_path"], agent_name: ctx.agent_name)
   pid, log_file = run_agent(prompt,
                             project_config: ctx.project_config, chdir: worktree_path,
                             log_name: "mention-#{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, cli_provider: ctx.cli_provider_override,
-                            source_context: { card_number: card_number },
-                            message: ctx.plain_text, channel: "Fizzy comment",
-                            context: intent_ctx)
-  return [200, { status: "intent_skip", agent: ctx.agent_name, card: card_number }.to_json] unless pid
+                            source_context: { card_number: card_number })
+  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)
 
@@ -517,11 +527,15 @@ def dispatch_followup_comment(ctx, card_key:, card_number:, work_dir:)
   effort = detect_effort(ctx.project_config, tags: card_tags, text: ctx.plain_text)
 
   is_worktree = work_dir != ctx.project_config["repo_path"]
-  should_resume = is_worktree && resume_viable?(
+  should_resume = is_worktree && !ctx.fresh && resume_viable?(
     project_config: ctx.project_config, cli_provider: ctx.cli_provider_override,
     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
+
   prompt = if should_resume
              LOG.info "[Resume] Using lean prompt for follow-up on card #{card_number || ctx.card_internal_id}"
              render_resume_prompt(
@@ -532,7 +546,6 @@ def dispatch_followup_comment(ctx, card_key:, card_number:, work_dir:)
              build_followup_prompt(ctx, card_number, card_tags, work_dir)
            end
 
-  intent_ctx = fetch_intent_context(card_number, repo_path: ctx.project_config["repo_path"], agent_name: ctx.agent_name)
   pid, log_file = run_agent(prompt,
                             project_config: ctx.project_config, chdir: work_dir,
                             log_name: "followup-#{card_number || ctx.card_internal_id}",
@@ -542,10 +555,8 @@ def dispatch_followup_comment(ctx, card_key:, card_number:, work_dir:)
                             source_context: {
                               card_number: card_number, card_internal_id: ctx.card_internal_id,
                               deploy_intent: ctx.deploy_intent
-                            },
-                            message: ctx.plain_text, channel: "Fizzy comment",
-                            context: intent_ctx)
-  return [200, { status: "intent_skip", agent: ctx.agent_name, card: card_number }.to_json] unless pid
+                            })
+  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)
 

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

@@ -116,6 +116,95 @@ module Brainiac
           Run any UAT testing steps defined in the card or acceptance criteria.
           Post results as a comment on the card.
         PROMPT
+
+        PLANNING_MODE = <<~PROMPT
+          ## Planning Mode (ACTIVE)
+
+          You are in **planning mode**. Your job is to gather requirements and break down the work into actionable tasks.
+
+          ### Your Role
+          - Ask clarifying questions to understand the problem, constraints, and desired outcome
+          - Continue asking until you have a clear picture (don't rush to a plan)
+          - Understand user intent naturally — "go ahead", "that's enough", "proceed" all mean the same thing
+          - When you have enough information OR the user signals they're ready, generate the plan
+
+          ### Question Guidelines
+          - Ask specific, focused questions (not generic "anything else?")
+          - Build on previous answers — reference what you've learned
+          - Prioritize questions that would significantly change the approach
+          - If you're 90% confident, proceed. If you're 60% confident, ask.
+
+          ### When to Stop Asking
+          The user will signal they're ready in natural language:
+          - "go ahead", "proceed", "that's enough", "looks good", "yeah do it"
+          - "I think you have enough", "start working", "make the plan"
+
+          You should also stop if:
+          - You've asked 5+ questions and have a clear understanding
+          - The user is getting impatient or frustrated
+          - The remaining unknowns are minor details you can decide yourself
+
+          ### Generating the Plan
+          When ready, create a plan file at `{{PLAN_FILE}}` with this structure:
+
+          ```markdown
+          # Feature: [Title]
+
+          ## Problem Statement
+          [What we're solving and why]
+
+          ## Requirements
+          - Requirement 1
+          - Requirement 2
+          - Requirement 3
+
+          ## Approach
+          [High-level strategy and key decisions]
+
+          ## Task Breakdown
+          ### Task 1: [Clear, actionable title]
+          - **Objective**: [What this task accomplishes]
+          - **Approach**: [How to implement it]
+          - **Demo**: [What "done" looks like]
+
+          ### Task 2: [Clear, actionable title]
+          - **Objective**: [What this task accomplishes]
+          - **Approach**: [How to implement it]
+          - **Demo**: [What "done" looks like]
+
+          [Continue for all tasks...]
+          ```
+
+          ### Memory Management
+          Log every question and answer to your memory file in this format:
+
+          ```
+          ## Planning Q&A
+          Q: [Your question]
+          A: [User's answer]
+
+          Q: [Next question]
+          A: [User's answer]
+          ```
+
+          Also track:
+          - `planning_complete: false` (update to `true` when plan is generated)
+          - Key decisions and constraints discovered
+          - Any blockers or unknowns that remain
+
+          ### After Planning
+          Once you've written the plan file:
+          1. Update memory with `planning_complete: true`
+          2. Post a comment summarizing the plan and linking to the file
+          3. The system will automatically create Fizzy steps from your task breakdown
+
+          ### Important
+          - You are READ-ONLY during planning — no code changes, no commits
+          - Focus on understanding the problem, not solving it yet
+          - The plan should be detailed enough that any agent could execute it
+          - Task titles should be clear and actionable (they become Fizzy step names)
+
+        PROMPT
       end
     end
   end

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

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

metadata

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