brainiac-discord 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 223dd60e819a0b61ff8b4f82e27cf88774d431b2a2673f82e5e5d7724ca6ed9b
-  data.tar.gz: 1777674edaec7db3e0772bdc3fa55d3f7438b1c0fba4c2450c50cd78ffa46442
+  metadata.gz: cdd8beafe4070560e4caaaa465d2b1e9dde33defa1b7fdc429467864776d3c21
+  data.tar.gz: 8714538569c7c1211a93ffa567401fe54197ce975fb3946e1524550f67cacb97
 SHA512:
-  metadata.gz: 3a2f08e64fa903bd185a7c4a09a279a5dd23425b744e59f0e5e4bd17bc7d9adb841bef15d7f1c09b614ff89587fac1ed01a11bf38edb10059e06956e21816358
-  data.tar.gz: 3dd471e951c05a947837a55ab5f9c6510e798eb41d2d86c65ab13c0264b29804e48de6cf430654639d5076db912c1093bee6578ad307a0bde56ad51a51309cb8
+  metadata.gz: a072c85e99b507dc4cdf65ec04cb9ed1d83e3ef22ef6ba77bd2866b7e04d947920cd607e087be3c93b06d362ef2e94127903e5087b8e9b7a85c456be72684b6f
+  data.tar.gz: 481b0308e707c86fddc515ba26a079bb23c31bb1f0f0f42da00cc7d798af52a24f6f8ea40f75356675f856f037b4e7dafa4174e1d62589569379bdc36e26f401

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

@@ -269,6 +269,45 @@ module Brainiac
       def self.completions
         %w[setup config default map owner token status]
       end
+
+      # Called by brainiac CLI after `agent create` — prompts for Discord user ID.
+      def self.on_agent_created(agent_key, entry)
+        return unless $stdin.tty?
+
+        display_name = entry["display_name"] || agent_key.capitalize
+        puts ""
+        puts "  [Discord] Configure Discord for #{display_name}?"
+        print "  Discord user ID (or blank to skip): "
+        user_id = $stdin.gets&.chomp
+        return if user_id.nil? || user_id.empty?
+
+        config_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "discord.json")
+        config = File.exist?(config_file) ? JSON.parse(File.read(config_file)) : {}
+        config["user_mappings"] ||= {}
+        config["user_mappings"][display_name] = user_id
+        File.write(config_file, JSON.pretty_generate(config))
+        puts "  ✓ Added #{display_name} → #{user_id} to discord.json user_mappings"
+      rescue JSON::ParserError => e
+        puts "  ⚠ Could not update discord.json: #{e.message}"
+      end
+
+      # Called by brainiac CLI after `agent remove` — removes from Discord user_mappings.
+      def self.on_agent_removed(agent_key, display_name)
+        config_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "discord.json")
+        return unless File.exist?(config_file)
+
+        config = JSON.parse(File.read(config_file))
+        mappings = config["user_mappings"]
+        return unless mappings
+
+        removed = mappings.delete(display_name) || mappings.delete(agent_key)
+        return unless removed
+
+        File.write(config_file, JSON.pretty_generate(config))
+        puts "  [Discord] Removed #{display_name} from discord.json user_mappings"
+      rescue JSON::ParserError
+        nil
+      end
     end
   end
 end

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

@@ -79,6 +79,27 @@ module Brainiac
             end
           end
 
+          # Start a single bot gateway connection dynamically (e.g. after agent is added).
+          # No-op if the bot is already running.
+          def start_bot!(agent_key, token)
+            @bots_mutex.synchronize do
+              return if @bots[agent_key]
+
+              @bots[agent_key] = { token: token, status: "starting", user_id: nil }
+            end
+            start_gateway_for(agent_key, token)
+          end
+
+          # Stop a bot gateway connection (e.g. after agent is removed).
+          # Removes it from the bots hash so it won't be matched in detect_sender_agent.
+          def stop_bot!(agent_key)
+            info = @bots_mutex.synchronize { @bots.delete(agent_key) }
+            return unless info
+
+            info[:thread]&.kill
+            LOG.info "[Discord] Gateway stopped for #{agent_key}" if defined?(LOG)
+          end
+
           # Summary of all bot statuses for the API endpoint.
           def bots_status
             @bots_mutex.synchronize do
@@ -122,7 +143,7 @@ module Brainiac
           private
 
           def start_gateway_for(agent_key, bot_token)
-            Thread.new do
+            thread = Thread.new do
               agent_display = agent_display_name(agent_key) || agent_key.capitalize
               bot_user_id = nil
 
@@ -136,13 +157,19 @@ module Brainiac
                 sleep 5
               end
             end
+            @bots_mutex.synchronize { @bots[agent_key][:thread] = thread if @bots[agent_key] }
           end
 
           def run_gateway_connection(agent_key, agent_display, bot_token, bot_user_id)
-            @bots_mutex.synchronize do
-              @bots[agent_key] ||= {}
-              @bots[agent_key][:status] = "connecting"
-              @bots[agent_key][:token] = bot_token
+            # Capture module-level ivars in local variables so the event_emitter
+            # blocks (which run via instance_exec on the WS client) can access them.
+            bots = @bots
+            bots_mutex = @bots_mutex
+
+            bots_mutex.synchronize do
+              bots[agent_key] ||= {}
+              bots[agent_key][:status] = "connecting"
+              bots[agent_key][:token] = bot_token
             end
 
             LOG.debug "[Discord:#{agent_display}] Connecting to Gateway..." if defined?(LOG) && LOG.respond_to?(:debug)
@@ -168,8 +195,8 @@ module Brainiac
             end
 
             ws.on :close do |_e|
-              @bots_mutex.synchronize do
-                @bots[agent_key][:status] = "disconnected" if @bots[agent_key]
+              bots_mutex.synchronize do
+                bots[agent_key][:status] = "disconnected" if bots[agent_key]
               end
               LOG.warn "[Discord:#{agent_display}] WebSocket closed" if defined?(LOG)
               heartbeat_thread&.kill

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

@@ -31,7 +31,10 @@ module Brainiac
             channel_info, is_thread, is_dm, in_own_thread = detect_channel_context(message, channel_id, mentioned, is_reply_to_bot, bot_token,
                                                                                    bot_user_id)
             return if should_stand_down?(in_own_thread, mentioned, is_reply_to_bot, is_bot, agent_key, mentions, content)
-            return unless mentioned || in_own_thread || is_dm || is_reply_to_bot
+
+            is_thread_participant = !mentioned && !in_own_thread && is_thread &&
+                                    thread_participant?(channel_id, message_id, bot_user_id, bot_token)
+            return unless mentioned || in_own_thread || is_dm || is_reply_to_bot || is_thread_participant
 
             record_human_comment("discord-#{channel_id}") unless is_bot
 
@@ -158,6 +161,24 @@ module Brainiac
             other_bot_mentioned
           end
 
+          # Check if this bot was previously mentioned in the thread (making it a participant).
+          # Uses a small history fetch to avoid excessive API calls.
+          def thread_participant?(channel_id, before_message_id, bot_user_id, bot_token)
+            messages = Api.request(:get, "/channels/#{channel_id}/messages?before=#{before_message_id}&limit=50", token: bot_token)
+            return false unless messages.is_a?(Array)
+
+            bot_id_str = bot_user_id.to_s
+            messages.any? do |msg|
+              mentions = msg["mentions"] || []
+              mentions.any? { |m| m["id"].to_s == bot_id_str } ||
+                (msg["content"] || "").match?(/<@!?#{Regexp.escape(bot_id_str)}>/) ||
+                msg.dig("author", "id").to_s == bot_id_str
+            end
+          rescue StandardError => e
+            LOG.warn "[Discord] Failed to check thread participation: #{e.message}" if defined?(LOG)
+            false
+          end
+
           def prepare_content(content, bot_user_id)
             content.gsub(/<@!?#{bot_user_id}>/, "").strip
           end
@@ -284,6 +305,12 @@ module Brainiac
               return
             end
             handle_supersede(is_bot, supersede_key, discord_user, agent_name, bot_token)
+
+            if intent_skip?(clean_content, agent_name: agent_name, source: :discord, channel: "Discord #{is_thread ? "thread" : "channel"}")
+              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)
@@ -567,8 +594,7 @@ module Brainiac
 
           def thread_resume?(project_config, clean_content, thread_cli_provider, agent_name)
             effective_provider = detect_cli_provider(text: clean_content) || thread_cli_provider
-            resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_provider, agent_name: agent_name)
-            resolved["resume_flag"] ? true : false
+            resume_viable?(project_config: project_config, cli_provider: effective_provider, agent_name: agent_name)
           end
 
           def detect_thread_overrides(project_config, clean_content, fallback_cli: nil, fallback_model: nil, fallback_effort: nil)
@@ -630,7 +656,7 @@ module Brainiac
                            discord_user:, channel_name:, reply_context:, channel_history:, thread_root_context:,
                            project_context:, response_file:, card_id:, brain_context:, agent_name:)
             if should_resume && thread_worktree_path
-              return render_discord_resume_prompt(
+              return Brainiac::Plugins::Discord::Prompts.render_resume(
                 message_body: clean_content_for_prompt, discord_user: discord_user,
                 response_file: response_file, agent_name: agent_name, card_id: card_id
               )

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

@@ -103,6 +103,33 @@ module Brainiac
 
           **IMPORTANT: Write your response to `{{RESPONSE_FILE}}`. Do NOT reply via stdout.**
         PROMPT
+
+        # Lean resume prompt for Discord threads. The previous session has full context
+        # (role, persona, knowledge, instructions). We only send the new message.
+        def self.render_resume(message_body:, discord_user:, response_file:, agent_name: AI_AGENT_NAME, card_id: nil)
+          memory_dir = memory_dir_for(agent_name)
+          if card_id
+            memory_file = File.join(memory_dir, "card-#{card_id}.md")
+            FileUtils.mkdir_p(memory_dir)
+            FileUtils.touch(memory_file)
+          end
+
+          lines = []
+          lines << "## Resumed Session — New Discord Message"
+          lines << ""
+          lines << "This is a continuation of your previous session in this thread."
+          lines << "All prior context, instructions, and your previous work are still in this conversation."
+          lines << ""
+          lines << "### New Message from #{discord_user}"
+          lines << ""
+          lines << message_body
+          lines << ""
+          lines << "---"
+          lines << "**IMPORTANT: Write your response to `#{response_file}`. Do NOT reply via stdout.**"
+          lines << "All your previous instructions still apply (memory, persona, one message per session, etc.)."
+
+          lines.join("\n")
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.1"
+      VERSION = "0.0.4"
     end
   end
 end

data/lib/brainiac/plugins/discord.rb

@@ -31,6 +31,9 @@ module Brainiac
           # Register crash handler
           register_crash_handler!
 
+          # Register agent lifecycle hooks
+          register_agent_lifecycle_hooks!
+
           # Start all per-agent Discord bot gateway connections
           Brainiac::Plugins::Discord::Gateway.start_all!
 
@@ -45,6 +48,30 @@ module Brainiac
 
         private
 
+        def register_agent_lifecycle_hooks!
+          Brainiac.on(:agent_added) do |ctx|
+            agent_key = ctx[:agent_key]
+            entry = ctx[:entry]
+            display_name = ctx[:display_name]
+            next unless entry.is_a?(Hash)
+
+            token = (entry["env"] || {})["DISCORD_BOT_TOKEN"]
+            if token
+              # Start a gateway connection for the new agent's bot
+              Gateway.start_bot!(agent_key, token)
+              LOG.info "[Discord] Started bot for new agent: #{display_name}" if defined?(LOG)
+            end
+          end
+
+          Brainiac.on(:agent_removed) do |ctx|
+            agent_key = ctx[:agent_key]
+
+            # Stop the gateway connection if running
+            Gateway.stop_bot!(agent_key)
+            LOG.info "[Discord] Stopped bot for removed agent: #{agent_key}" if defined?(LOG)
+          end
+        end
+
         def register_notification_handler!
           Brainiac.on(:notify) do |ctx|
             next unless ctx[:channel].to_s == "discord"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-discord
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - Andy Davis
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.14
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
   requirement: !ruby/object:Gem::Requirement