brainiac-fizzy 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3d24ce3986d1b5353dca763a8ba29060ecd2dce47065cc2ffdd201d4075ca66
-  data.tar.gz: 6f39b2c02369556d1b7914c7a37eebcb98eccf016944ed2ea34bba6dac94ebc4
+  metadata.gz: 50d4aa7e239474b5b5046d0d0e98d4b5d1d5aa7faf5c8ff3fe4a69207fa477d2
+  data.tar.gz: a622fb92c3fef1d669ea2f910968c2295929a95bb32319541513a47ccdf7addc
 SHA512:
-  metadata.gz: b417b22c6c7150d3cf823225141d00ae41d94d3f2a6e6c3eb736f4db2ea122ce33b46a0c5d237e4315cf29f415b82b31fa58085a1a48e83177288314bdc8df11
-  data.tar.gz: 61d02c8a206ecd4c0e3c9680b3f8856914c30b45a16d9a7507b6118c980c0765fa24e96e4018bbb3793dd357e84de99ee39551b3724c7dba421927b8b679b89e
+  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/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
 

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)
@@ -91,18 +106,42 @@ 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),
+    fresh: tags[:fresh],
     comment_vars: {
       "COMMENT_CREATOR" => creator_name || "Unknown",
       "COMMENT_ID" => comment_id.to_s,
@@ -362,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)
 
@@ -470,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)
 
@@ -494,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(
@@ -509,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}",
@@ -519,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.9"
+      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.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Andy Davis