brainiac-discord 0.0.9 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed2e8f74f05207e45944b37b43094298419d007ed897dac9987f97d86a03152b
-  data.tar.gz: 9ac14bdbb6e5481d7b36a8734f8b4beb66eb7b8299caa1459e47c6389f186101
+  metadata.gz: e8d2bbbf0efaa83da8904137abf18a256f79e5073fe5896390c0afa1f880856f
+  data.tar.gz: 9b9a19c746dd57d13b232a6864918b99acf9a54128213dac2ff1c0328b90e242
 SHA512:
-  metadata.gz: c74ff0656c3790f82604c8162c826758b5ca57ea0eecb71adc5e7fcf7d78ee6eccebb110dffada6a6ba4e74456c75c98fdcee88679cbd2716a52d73f53231cf6
-  data.tar.gz: 9c5ffd03b96f76668d2cbfcfb54bebd93af6ca2501f7d952d635a9db75f2cd712d3e40274e23dee877fc835ac0a305264eb27b5383411e4b35288477a236e038
+  metadata.gz: 8af3d015077e894932bf05ae2940b8bc9d69895874b88ed548e51c01469a2257bc2bda5dd162a601c775c4745567c257a16c0091b52f5ae4854f4ebb42fecfd3
+  data.tar.gz: bbda431894c7453f4e6a8f9b8c6747884cc9cf39c01a0b812dd7f9a812a5afff63fbbc0f2171ccee88c7deabfd3eeac7216910efbb01b24def1d4d3270ad4db0

data/README.md

@@ -14,7 +14,7 @@ Each agent gets its own Discord bot. Users @mention @Galen or @GLaDOS directly
 - **Emoji feedback** — non-reserved emoji reactions are logged as feedback to the agent's persona
 - **Thread isolation** — conversations get their own threads with worktree persistence
 - **Forum support** — cron jobs can post to forum channels
-- **GIF support** — agents can search and embed GIFs via GIPHY API
+- **GIF support** — agents can search and embed GIFs via Klipy API (formerly GIPHY)
 - **Draft delivery** — file-based response delivery survives server restarts
 
 ## Installation
@@ -92,7 +92,8 @@ Stored in `~/.brainiac/discord.json`:
   },
   "authorized_role_ids": [],
   "authorized_user_ids": [],
-  "giphy_api_key": "your-giphy-api-key"
+  "giphy_api_key": null,
+  "klipy_api_key": "your-klipy-api-key"
 }
 ```
 

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

@@ -192,18 +192,21 @@ module Brainiac
           # --- GIF Search ---
 
           def search_gif(query)
-            api_key = Config.giphy_api_key
+            api_key = Config.klipy_api_key
             return [] unless api_key
 
-            uri = URI("https://api.giphy.com/v1/gifs/search")
-            uri.query = URI.encode_www_form(api_key: api_key, q: query, limit: 5, rating: "pg-13")
+            uri = URI("https://api.klipy.com/v2/search")
+            uri.query = URI.encode_www_form(key: api_key, q: query, limit: 5, contentfilter: "medium")
             http = Net::HTTP.new(uri.host, uri.port)
             http.use_ssl = true
             response = http.get(uri)
             return [] unless response.code.to_i == 200
 
             data = JSON.parse(response.body)
-            (data["data"] || []).map { |g| { "url" => g.dig("images", "original", "url") || g["url"] } }
+            (data["results"] || []).filter_map do |r|
+              url = r.dig("media_formats", "gif", "url") || r.dig("media_formats", "mediumgif", "url") || r["url"]
+              { "url" => url } if url
+            end
           rescue StandardError => e
             LOG.warn "[Discord] GIF search error: #{e.message}" if defined?(LOG)
             []

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

@@ -53,8 +53,8 @@ module Brainiac
             @config["dashboard_token"]
           end
 
-          def giphy_api_key
-            @config["giphy_api_key"]
+          def klipy_api_key
+            @config["klipy_api_key"] || @config["giphy_api_key"]
           end
 
           def channel_mappings

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}"
@@ -528,7 +564,7 @@ module Brainiac
               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) ||
@@ -823,7 +859,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 +867,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
@@ -891,7 +931,8 @@ 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
 
@@ -985,10 +1026,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 +1075,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 +1216,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

@@ -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.9"
+      VERSION = "0.0.11"
     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.9
+  version: 0.0.11
 platform: ruby
 authors:
 - Andy Davis