brainiac-discord 0.0.10 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 753751521918bfaf9dbbd4481272289b5e56109c8a6607a4f9bee5bb6d4158fe
-  data.tar.gz: 143f91e2f62daec56217695b50c6d11f7b22b8d02996600ff2bc04059dacfd92
+  metadata.gz: 1f2f87e89db33072e4ceb141ec472b71ce09f22d3a383da595f195f3f441b9ee
+  data.tar.gz: 69aeb6d7e6f945f0fb517c8bfd37a6d91e749137d634d5578596a462579044b2
 SHA512:
-  metadata.gz: 199e2440232277e9068b31a59bd407dc5b6e3c736e313da1eed4b4ad64f0ebb5b6f7fce1edc7f3e928560534b7167ae64d945683432c792d83c99e6dbdabc9d2
-  data.tar.gz: 7625990b00a2b3e1629d11a7eed4ae5947e662cd28d1514dd65bcc1ad689eedf7e9c42020c7e6a884ee35594a2aa229207d144302e51f4ff4d8a6300665eaf84
+  metadata.gz: 2eab7e192cfe422009193273e88bbf8aab1b8ccecdf3d33d7643847b4799a55f44bb5c3d5f18c56eea753982491c73426942e420a1d99c418867829c9bb65fdf
+  data.tar.gz: 6f66c81ea46ac32423fb10a542730c3e2c71d6d7db71b959ef188b93effa68a12932f4e8e52cc1d203473882355d78339058320dbba9eb61eb8e88d62a479700

data/lib/brainiac/plugins/discord/delivery.rb

@@ -12,8 +12,9 @@ module Brainiac
       # A poller thread recovers orphaned drafts (e.g. after a server restart).
       module Delivery
         BRAINIAC_DIR_PATH = ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac"))
-        DRAFT_DIR  = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "draft")
-        POSTED_DIR = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "posted")
+        DRAFT_DIR   = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "draft")
+        POSTED_DIR  = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "posted")
+        PENDING_DIR = File.join(BRAINIAC_DIR_PATH, "tmp", "discord", "pending")
 
         POLLER_INTERVAL = 5   # seconds
         DRAFT_MIN_AGE = 30    # seconds — don't race the monitoring thread
@@ -30,6 +31,7 @@ module Brainiac
           def ensure_dirs!
             FileUtils.mkdir_p(DRAFT_DIR)
             FileUtils.mkdir_p(POSTED_DIR)
+            FileUtils.mkdir_p(PENDING_DIR)
           end
 
           def start_poller!

data/lib/brainiac/plugins/discord/message.rb

@@ -254,7 +254,7 @@ module Brainiac
             # Also check user_mappings for remote agent bots not connected locally
             agent_keys = []
             Gateway.each_bot { |key, _| agent_keys << key }
-            Config.user_mappings.each do |name, _discord_id|
+            Config.user_mappings.each_key do |name|
               normalized = name.downcase.gsub(/[^a-z0-9]/, "-")
               next if normalized == agent_key
               next if agent_keys.include?(normalized)
@@ -389,9 +389,7 @@ module Brainiac
           end
 
           def route_dispatch(agent_key:, agent_name:, bot_token:, is_bot:, channel_id:, message_id:, message:,
-                             clean_content:, clean_content_for_prompt:, chat_mode:, fresh: false, is_thread:, is_dm:,
-                             channel_info:, parent_channel_id:, discord_user:, reply_context:,
-                             channel_history:, project_key:, project_config:, attachment_paths:,
+                             clean_content:, clean_content_for_prompt:, chat_mode:, is_thread:, is_dm:, channel_info:, parent_channel_id:, discord_user:, reply_context:, channel_history:, project_key:, project_config:, attachment_paths:, fresh: false,
                              directly_addressed: false)
             session_key = "discord-#{agent_key}-#{channel_id}-#{message_id}"
             supersede_key = "discord-#{agent_key}-#{channel_id}"
@@ -401,14 +399,24 @@ module Brainiac
             end
             handle_supersede(is_bot, supersede_key, discord_user, agent_name, bot_token)
 
-            unless directly_addressed
-              if intent_skip?(clean_content, agent_name: agent_name, source: :discord,
-                              channel: "Discord #{is_thread ? "thread" : "channel"}", context: channel_history)
-                LOG.info "[Discord:#{agent_name}] Intent skip — not dispatching for: #{clean_content[0..80]}" if defined?(LOG)
+            # If an agent is still running (in supersede window), queue the message
+            # for mid-session context injection instead of spawning a second agent.
+            unless is_bot
+              active = find_supersedable_session(supersede_key)
+              if active
+                queue_pending_message(supersede_key, discord_user, clean_content, attachment_paths)
+                Thread.new { Api.add_reaction(channel_id, message_id, "📎", token: bot_token) }
+                LOG.info "[Discord:#{agent_name}] Queued follow-up from #{discord_user} for active session #{active[:session_key]}" if defined?(LOG)
                 return
               end
             end
 
+            if !directly_addressed && intent_skip?(clean_content, agent_name: agent_name, source: :discord,
+                                                                  channel: "Discord #{is_thread ? "thread" : "channel"}", context: channel_history)
+              LOG.info "[Discord:#{agent_name}] Intent skip — not dispatching for: #{clean_content[0..80]}" if defined?(LOG)
+              return
+            end
+
             Thread.new do
               Api.remove_reaction(channel_id, message_id, "🛑", token: bot_token)
               Api.add_reaction(channel_id, message_id, "👀", token: bot_token)
@@ -459,6 +467,37 @@ module Brainiac
             (prev[:draft_files] || []).each { |f| FileUtils.rm_f(f) }
           end
 
+          def queue_pending_message(supersede_key, discord_user, content, attachment_paths)
+            FileUtils.mkdir_p(Delivery::PENDING_DIR)
+            safe_key = supersede_key.gsub(/[^a-zA-Z0-9-]/, "_")
+            timestamp = Time.now.strftime("%Y%m%d-%H%M%S-%L")
+            pending_file = File.join(Delivery::PENDING_DIR, "#{safe_key}-#{timestamp}.json")
+            payload = {
+              user: discord_user,
+              content: content,
+              timestamp: Time.now.iso8601,
+              attachments: attachment_paths || []
+            }
+            File.write(pending_file, JSON.pretty_generate(payload))
+          end
+
+          def pending_messages_for(supersede_key)
+            safe_key = supersede_key.gsub(/[^a-zA-Z0-9-]/, "_")
+            pattern = File.join(Delivery::PENDING_DIR, "#{safe_key}-*.json")
+            files = Dir.glob(pattern)
+            messages = files.filter_map do |f|
+              JSON.parse(File.read(f))
+            rescue JSON::ParserError
+              nil
+            end
+            [messages, files]
+          end
+
+          def clear_pending_messages(supersede_key)
+            _, files = pending_messages_for(supersede_key)
+            files.each { |f| FileUtils.rm_f(f) }
+          end
+
           def build_project_context(project_key, project_config, agent_name)
             if project_config
               repo_path = project_config["repo_path"]
@@ -484,10 +523,7 @@ module Brainiac
           end
 
           def dispatch_session(agent_key:, agent_name:, bot_token:, channel_id:, message_id:, message:,
-                               clean_content:, clean_content_for_prompt:, chat_mode:, fresh: false, is_thread:, is_dm:,
-                               channel_info:, parent_channel_id:, discord_user:, reply_context:,
-                               channel_history:, project_key:, project_config:, project_context:,
-                               session_key:, supersede_key:, attachment_paths:, is_bot:)
+                               clean_content:, clean_content_for_prompt:, chat_mode:, is_thread:, is_dm:, channel_info:, parent_channel_id:, discord_user:, reply_context:, channel_history:, project_key:, project_config:, project_context:, session_key:, supersede_key:, attachment_paths:, is_bot:, fresh: false)
             timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
             response_dir = File.join(Delivery::BRAINIAC_DIR_PATH, "tmp")
             response_basename = "discord-response-#{timestamp}-#{agent_key}-#{message_id}"
@@ -522,24 +558,34 @@ module Brainiac
               )
             end
 
+            # Resolve CLI overrides and work_dir BEFORE building the prompt so we can determine
+            # whether resume will actually work. This prevents sending a lean prompt when
+            # the CLI won't actually have session state.
+            work_dir = chat_mode_fallback(agent_key, agent_name, message_id, chat_mode, thread_worktree_path) ||
+                       (project_config ? project_config["repo_path"] : Dir.pwd)
+            model, effort, cli_provider_override = resolve_overrides(
+              clean_content, project_config, thread_model, thread_effort, thread_cli_provider
+            )
+            resolved = resolve_project_cli_config(project_config || DEFAULT_PROJECT,
+                                                  cli_provider_override: cli_provider_override, agent_name: agent_name)
+
+            # Convert should_resume to the actual flag/symbol. If resolve_resume returns false,
+            # we know the CLI won't actually resume, so we shouldn't send a lean prompt.
+            actual_resume = should_resume ? resolve_resume(true, resolved, work_dir) : false
+            use_lean_prompt = actual_resume && thread_worktree_path
+
             prompt = build_prompt(
-              should_resume: should_resume, thread_worktree_path: thread_worktree_path,
+              should_resume: use_lean_prompt, thread_worktree_path: thread_worktree_path,
               clean_content_for_prompt: clean_content_for_prompt,
               discord_user: discord_user, channel_name: channel_info&.dig("name") || channel_id, reply_context: reply_context,
               channel_history: channel_history, thread_root_context: thread_root_context,
               project_context: project_context, response_file: response_file, card_id: card_id,
-              brain_context: brain_context, agent_name: agent_name
+              brain_context: brain_context, agent_name: agent_name, supersede_key: supersede_key
             )
 
-            work_dir = chat_mode_fallback(agent_key, agent_name, message_id, chat_mode, thread_worktree_path) ||
-                       (project_config ? project_config["repo_path"] : Dir.pwd)
             prompt_file = File.join(response_dir, "discord-prompt-#{timestamp}-#{agent_key}-#{message_id}.md")
             File.write(prompt_file, prompt)
 
-            model, effort, cli_provider_override = resolve_overrides(
-              clean_content, project_config, thread_model, thread_effort, thread_cli_provider
-            )
-
             persist_overrides(thread_map_key, clean_content, project_config,
                               cli_provider: cli_provider_override, model: model, effort: effort,
                               prev_cli_provider: thread_cli_provider, prev_model: thread_model, prev_effort: thread_effort)
@@ -556,8 +602,8 @@ module Brainiac
               agent_key: agent_key, agent_name: agent_name, bot_token: bot_token,
               channel_id: channel_id, message_id: message_id, discord_user: discord_user,
               work_dir: work_dir, prompt_file: prompt_file, response_file: response_file,
-              meta_file: meta_file, model: model, effort: effort, should_resume: should_resume,
-              cli_provider_override: cli_provider_override, project_config: project_config,
+              meta_file: meta_file, model: model, effort: effort, actual_resume: actual_resume,
+              resolved: resolved, project_config: project_config,
               session_key: session_key, supersede_key: supersede_key,
               attachment_paths: attachment_paths, timestamp: timestamp, response_dir: response_dir
             )
@@ -823,7 +869,7 @@ module Brainiac
 
           def build_prompt(should_resume:, thread_worktree_path:, clean_content_for_prompt:,
                            discord_user:, channel_name:, reply_context:, channel_history:, thread_root_context:,
-                           project_context:, response_file:, card_id:, brain_context:, agent_name:)
+                           project_context:, response_file:, card_id:, brain_context:, agent_name:, supersede_key: nil)
             if should_resume && thread_worktree_path
               return Brainiac::Plugins::Discord::Prompts.render_resume(
                 message_body: clean_content_for_prompt, discord_user: discord_user,
@@ -831,12 +877,16 @@ module Brainiac
               )
             end
 
+            safe_key = supersede_key&.gsub(/[^a-zA-Z0-9-]/, "_") || "unknown"
+            pending_glob = File.join(Delivery::PENDING_DIR, "#{safe_key}-*.json")
+
             template_vars = {
               "DISCORD_USER" => discord_user, "CHANNEL_NAME" => channel_name,
               "MESSAGE_BODY" => clean_content_for_prompt, "REPLY_CONTEXT" => reply_context,
               "CHANNEL_HISTORY" => channel_history, "THREAD_ROOT_CONTEXT" => thread_root_context,
               "PROJECT_CONTEXT" => project_context, "RESPONSE_FILE" => response_file,
-              "COMMENT_CREATOR" => discord_user, "DISCORD_MENTION_ROSTER" => Api.mention_roster
+              "COMMENT_CREATOR" => discord_user, "DISCORD_MENTION_ROSTER" => Api.mention_roster,
+              "PENDING_MESSAGES_GLOB" => pending_glob
             }
 
             template_vars["CARD_ID"] = card_id
@@ -846,17 +896,15 @@ module Brainiac
 
           def spawn_agent(agent_key:, agent_name:, bot_token:, channel_id:, message_id:, discord_user:,
                           work_dir:, prompt_file:, response_file:, meta_file:, model:, effort:,
-                          should_resume:, cli_provider_override:, project_config:,
+                          actual_resume:, resolved:, project_config:,
                           session_key:, supersede_key:, attachment_paths:, timestamp:, response_dir:)
             agent_config_name = agent_key.downcase.gsub(/[^a-z0-9-]/, "-")
             log_file = File.join(response_dir, "discord-agent-#{timestamp}-#{agent_key}-#{message_id}.log")
 
-            resolved = resolve_project_cli_config(project_config || DEFAULT_PROJECT,
-                                                  cli_provider_override: cli_provider_override, agent_name: agent_name)
             cmd = build_agent_cmd(resolved, agent_config_name: agent_config_name, model: model, effort: effort,
-                                            prompt_file: prompt_file, resume: should_resume)
+                                            prompt_file: prompt_file, resume: actual_resume)
 
-            resume_note = should_resume ? ", resuming" : ""
+            resume_note = actual_resume ? ", resuming" : ""
             if defined?(LOG)
               LOG.info "[Discord:#{agent_name}] Dispatching for #{discord_user} " \
                        "(model: #{model || "default"}, effort: #{effort || "default"}, cli: #{resolved["agent_cli"]}#{resume_note}), tail -f #{log_file}"
@@ -870,6 +918,17 @@ module Brainiac
               LOG.info "[Discord:#{agent_name}] Injecting #{agent_env.size} env var(s): #{agent_env.keys.join(", ")}" if defined?(LOG)
             end
 
+            # Inject a GitHub App token so `gh`/`git` run as the agent's own bot
+            # identity (e.g. galen[bot]) instead of the host machine's personal
+            # `gh auth`. Without this, `gh pr create` in the prompt would open PRs
+            # under whoever is logged in on the box. No-op if the github plugin
+            # isn't loaded or the agent has no app configured.
+            gh_env = github_agent_token_env(agent_name, project_config)
+            unless gh_env.empty?
+              spawn_env.merge!(gh_env)
+              LOG.info "[Discord:#{agent_name}] Injecting GitHub App token (GH_TOKEN) for bot identity" if defined?(LOG)
+            end
+
             head_before, status_before = capture_brainiac_state(project_config, work_dir)
             prompt_mode = resolved["prompt_mode"] || "stdin"
 
@@ -891,10 +950,46 @@ module Brainiac
               message_id: message_id, bot_token: bot_token, response_file: response_file,
               meta_file: meta_file, prompt_file: prompt_file, log_file: log_file,
               attachment_paths: attachment_paths, project_config: project_config,
-              head_before: head_before, status_before: status_before
+              head_before: head_before, status_before: status_before,
+              supersede_key: supersede_key
             )
           end
 
+          # Build a { "GH_TOKEN" => ... } env hash so the spawned agent's `gh`
+          # and `git` invocations authenticate as the agent's own GitHub App bot
+          # rather than the host's personal `gh auth`. This is what makes the
+          # prompt's `gh pr create` open PRs under e.g. galen[bot].
+          #
+          # Reuses the brainiac-github plugin's AppClient. The github plugin is
+          # optional, so everything is guarded: if it isn't loaded, or no app is
+          # configured for the agent (or the shared "brainiac" app), we return an
+          # empty hash and `gh` falls back to whatever's authenticated on the box.
+          def github_agent_token_env(agent_name, project_config)
+            return {} unless agent_name && project_config
+
+            repo = project_config["github_repo"]
+            return {} unless repo && !repo.to_s.empty?
+
+            return {} unless defined?(Brainiac::Plugins::Github::AppClient)
+
+            client = Brainiac::Plugins::Github::AppClient
+            effective_agent = if client.configured?(agent_name)
+                                agent_name
+                              elsif client.configured?("brainiac")
+                                "brainiac"
+                              end
+            return {} unless effective_agent
+
+            repo_owner = repo.to_s.split("/").first
+            token = client.installation_token_for(effective_agent, repo_owner: repo_owner)
+            return {} unless token && !token.empty?
+
+            { "GH_TOKEN" => token }
+          rescue StandardError => e
+            LOG.warn "[Discord:#{agent_name}] Could not mint GitHub App token: #{e.message}" if defined?(LOG)
+            {}
+          end
+
           def capture_brainiac_state(project_config, work_dir)
             return [nil, nil] unless project_config
 
@@ -985,10 +1080,10 @@ module Brainiac
             Process.wait(pid)
             exit_status = $CHILD_STATUS.exitstatus
 
-            if exit_status == 0
+            if exit_status.zero?
               LOG.info "[Discord:#{agent_name}] [fresh] Memory refresh completed successfully" if defined?(LOG)
-            else
-              LOG.warn "[Discord:#{agent_name}] [fresh] Memory refresh failed (exit: #{exit_status}), proceeding anyway" if defined?(LOG)
+            elsif defined?(LOG)
+              LOG.warn "[Discord:#{agent_name}] [fresh] Memory refresh failed (exit: #{exit_status}), proceeding anyway"
             end
 
             Api.remove_reaction(channel_id, message_id, "📖", token: bot_token)
@@ -1034,11 +1129,14 @@ module Brainiac
 
           def monitor_agent(pid:, session_key:, agent_name:, agent_config_name:, channel_id:, message_id:,
                             bot_token:, response_file:, meta_file:, prompt_file:, log_file:,
-                            attachment_paths:, project_config:, head_before:, status_before:)
+                            attachment_paths:, project_config:, head_before:, status_before:, supersede_key: nil)
             Thread.new do
               Process.wait(pid)
               exit_status = $CHILD_STATUS
 
+              # Clean up any pending messages that the agent may not have consumed
+              clear_pending_messages(supersede_key) if supersede_key
+
               session_cancelled = ACTIVE_SESSIONS_MUTEX.synchronize { !ACTIVE_SESSIONS.key?(session_key) }
 
               if exit_status.signaled? || session_cancelled
@@ -1172,12 +1270,13 @@ module Brainiac
           # Detect transient CLI errors that don't warrant a full crash notification.
           # These are random upstream failures (model timeouts, tool approval glitches)
           # that resolve on retry — reacting with an emoji is sufficient.
-          TRANSIENT_CLI_ERROR_PATTERN = /
-            Failed\sto\sreceive\sthe\snext\smessage|
-            Kiro\sfailed\sto\sgenerate\sa\sresponse|
-            Tool\sapproval\srequired\sbut\s--no-interactive|
-            Kiro\sis\shaving\strouble\sresponding
-          /ix
+          TRANSIENT_CLI_ERROR_PATTERN = # rubocop:disable Lint/UselessConstantScoping
+            /
+              Failed\sto\sreceive\sthe\snext\smessage|
+              Kiro\sfailed\sto\sgenerate\sa\sresponse|
+              Tool\sapproval\srequired\sbut\s--no-interactive|
+              Kiro\sis\shaving\strouble\sresponding
+            /ix # rubocop:enable Lint/UselessConstantScoping
 
           def transient_cli_error?(log_file)
             return false unless log_file && File.exist?(log_file)

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

@@ -48,8 +48,8 @@ module Brainiac
           3. Make the changes, test if applicable
           4. Commit with a clear message
           5. Push the branch
-          6. Summarize what you did in your response file
-          7. If it's substantial or needs review, mention opening a PR (but don't create it unless asked)
+          6. Open a PR with `gh pr create --fill` (or with a descriptive body)
+          7. Summarize what you did in your response file, including a link to the PR
 
           **When responding conversationally:**
           - Answer questions about the codebase, architecture, conventions
@@ -84,6 +84,19 @@ module Brainiac
           - The current topic/focus as of this session
           This is the ONLY way future sessions will know what happened in the middle of the conversation.
 
+          ### Pending Follow-Up Messages (check BEFORE writing your response)
+          While you're working, the user may send additional messages that get queued for you.
+          Before writing your response file, check for pending messages:
+          ```bash
+          ls {{PENDING_MESSAGES_GLOB}} 2>/dev/null
+          ```
+          If any files exist, read them — they contain JSON with `user`, `content`, and `timestamp`.
+          Incorporate the follow-up context into your response. Address anything new the user said.
+          After reading them, delete the pending files:
+          ```bash
+          rm -f {{PENDING_MESSAGES_GLOB}}
+          ```
+
         PROMPT
 
         SITUATION = <<~'PROMPT'

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.10"
+      VERSION = "0.0.13"
     end
   end
 end

data/lib/brainiac/plugins/discord.rb

@@ -89,7 +89,8 @@ module Brainiac
 
             # Handle forum posts
             if ctx[:forum_title] && Api.forum_channel?(target, token: token)
-              Api.create_forum_post(target, title: ctx[:forum_title], content: message, token: token)
+              title = "#{ctx[:forum_title]} — #{Time.now.strftime("%b %d, %Y")}"
+              Api.create_forum_post(target, title: title, content: message, token: token)
             elsif ctx[:forum_reply_to_latest] && Api.forum_channel?(target, token: token)
               latest = Api.find_latest_forum_thread(target, token: token)
               if latest
@@ -97,6 +98,9 @@ module Brainiac
               else
                 Api.send_long_message(target, message, token: token)
               end
+            elsif Api.forum_channel?(target, token: token)
+              title = "#{agent || "Notification"} — #{Time.now.strftime("%b %d, %Y")}"
+              Api.create_forum_post(target, title: title, content: message, token: token)
             else
               Api.send_long_message(target, message, token: token)
             end

metadata

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