brainiac-discord 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f25b1975521590991edab7777fc07cb22083c2c151998f42bc4f0151bc6b5f11
-  data.tar.gz: ba4aeb7c4559d80bc0fea056ec8e0505ad884ffa5ac6945e648d830f357e2b9e
+  metadata.gz: 5edd0068ecc82d20372d269791ff8e750fcec8106f4adcc99fdef3c252e03ada
+  data.tar.gz: b30c999fc3497d7608463975a3d9f4a8c09b135e3d7bc9da1099b6a5306594c2
 SHA512:
-  metadata.gz: 2ac2c2933550c7a524d74f443e119d8c83c84cd1e3857c66a9ef57a4784694359e2004947bc8174ea3a28363fe247b145ef04034bc12bc31ed3a826f2be2d4a1
-  data.tar.gz: a9ac55676eb5b6b75ffc2d74b146e1023783313c0e5aca96159f9845a814dd184427e958102b6b7a173e41ab4f67b11532d72a7d104e64d7b767c97d4f1bd242
+  metadata.gz: f65f1deefed415c9b3a038162ad6c59714f2677c9ce8ec201e880ce9ae9b159571cb4910a7515268d0e09ad262e69011ea6f7b1c40471bc846ea5f84fa74d366
+  data.tar.gz: 23ba4bda9f6eb4e9797e6724ad57f12908da3176f116eacdaa11f8b5c3462647180cb8c0a1a1766c00ac12de49c2216e8fdf84da9ad719dcde0bae42307851f9

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/config.rb

@@ -75,6 +75,18 @@ module Brainiac
             end.map(&:to_s)
           end
 
+          # Find the Discord role ID for a given agent key.
+          # Checks role_mappings and authorized_role_ids (when Hash) by agent display name.
+          # Returns the role ID string, or nil if not found.
+          def role_id_for_agent(agent_key)
+            roles = @config["role_mappings"] || (@config["authorized_role_ids"].is_a?(Hash) ? @config["authorized_role_ids"] : nil)
+            return nil unless roles
+
+            # Try capitalized key first (e.g., "galen" → "Galen"), then display name from registry
+            agent_name = agent_display_name(agent_key) || agent_key.capitalize
+            roles[agent_name]&.to_s
+          end
+
           def authorized_user_ids
             @config["authorized_user_ids"] || []
           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,6 +157,7 @@ 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)
@@ -273,6 +295,26 @@ module Brainiac
               rescue StandardError => e
                 LOG.error "[Discord:#{agent_display}] Error handling reaction: #{e.message}\n#{e.backtrace.first(3).join("\n")}" if defined?(LOG)
               end
+            when "THREAD_UPDATE"
+              if data.dig("thread_metadata", "archived")
+                Thread.new do
+                  ThreadCleanup.handle_archive(data, agent_key, agent_display)
+                rescue StandardError => e
+                  if defined?(LOG)
+                    LOG.error "[Discord:#{agent_display}] Error handling thread archive: " \
+                              "#{e.message}\n#{e.backtrace.first(3).join("\n")}"
+                  end
+                end
+              end
+            when "THREAD_DELETE"
+              Thread.new do
+                ThreadCleanup.handle_archive(data, agent_key, agent_display)
+              rescue StandardError => e
+                if defined?(LOG)
+                  LOG.error "[Discord:#{agent_display}] Error handling thread delete: " \
+                            "#{e.message}\n#{e.backtrace.first(3).join("\n")}"
+                end
+              end
             end
 
             bot_user_id
@@ -281,6 +323,7 @@ module Brainiac
           def mark_bot_ready(agent_key, agent_display, bot_user_id, data)
             @bots_mutex.synchronize do
               @bots[agent_key][:user_id] = bot_user_id
+              @bots[agent_key][:username] = data.dig("user", "username")
               @bots[agent_key][:status] = "ready"
             end
             guild_count = data["guilds"]&.size || 0

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

@@ -24,14 +24,22 @@ module Brainiac
 
             mentions = message["mentions"] || []
             mentioned = mentions.any? { |m| m["id"].to_s == bot_user_id.to_s } ||
-                        content.match?(/<@!?#{Regexp.escape(bot_user_id.to_s)}>/)
+                        content.match?(/<@!?#{Regexp.escape(bot_user_id.to_s)}>/) ||
+                        role_mentioned?(message, content, agent_key)
             return if sender_agent_key && !validate_cross_agent_dispatch(sender_agent_key, agent_key, mentioned, content, channel_id)
 
             is_reply_to_bot, referenced_message = detect_reply_to_bot(message, channel_id, mentioned, bot_token, bot_user_id)
             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
+
+            # When another agent is explicitly mentioned, thread participants who weren't
+            # addressed should not activate — the message was directed at someone specific.
+            return if is_thread_participant && other_agent_mentioned?(mentions, content, agent_key)
 
             record_human_comment("discord-#{channel_id}") unless is_bot
 
@@ -59,6 +67,14 @@ module Brainiac
             tags = parse_inline_tags(clean_content)
             project_key, project_config = resolve_project(tags[:project], parent_channel_id, agent_name, channel_id, message_id, bot_token)
 
+            # Thread owners bypass intent checking ONLY when they're the sole agent in
+            # the thread (1-on-1 with the human). If other agents have participated,
+            # everyone goes through intent checking unless explicitly @mentioned.
+            solo_thread_owner = in_own_thread && solo_in_thread?(channel_history, agent_key)
+            if in_own_thread && defined?(LOG)
+              LOG.info "[Discord:#{agent_name}] Own thread — #{solo_thread_owner ? "solo (bypassing intent)" : "multi-agent (intent check applies)"}"
+            end
+
             route_dispatch(
               agent_key: agent_key, agent_name: agent_name, bot_token: bot_token, is_bot: is_bot,
               channel_id: channel_id, message_id: message_id, message: message,
@@ -67,12 +83,44 @@ module Brainiac
               channel_info: channel_info, parent_channel_id: parent_channel_id,
               discord_user: discord_user, reply_context: reply_context,
               channel_history: channel_history, project_key: project_key,
-              project_config: project_config, attachment_paths: attachment_paths
+              project_config: project_config, attachment_paths: attachment_paths,
+              directly_addressed: mentioned || is_reply_to_bot || is_dm || solo_thread_owner
             )
           end
 
           private
 
+          # Check if the agent's Discord role was @mentioned in this message.
+          # Discord role mentions use <@&ROLE_ID> syntax and populate mention_roles array.
+          def role_mentioned?(message, content, agent_key)
+            role_id = Config.role_id_for_agent(agent_key)
+            return false unless role_id
+
+            mention_roles = message["mention_roles"] || []
+            mention_roles.any? { |r| r.to_s == role_id } ||
+              content.match?(/<@&#{Regexp.escape(role_id)}>/)
+          end
+
+          # Check if another agent bot is explicitly mentioned in this message.
+          # When a user @mentions a specific agent, thread participants who weren't
+          # mentioned should stay silent — no intent check needed.
+          def other_agent_mentioned?(mentions, content, agent_key)
+            mention_roles = []
+
+            Gateway.each_bot do |key, info|
+              next if key == agent_key
+              next unless info[:user_id]
+
+              return true if mentions.any? { |m| m["id"].to_s == info[:user_id].to_s } ||
+                             content.match?(/<@!?#{Regexp.escape(info[:user_id].to_s)}>/)
+
+              role_id = Config.role_id_for_agent(key)
+              mention_roles << role_id if role_id
+            end
+
+            mention_roles.any? { |rid| content.match?(/<@&#{Regexp.escape(rid)}>/) }
+          end
+
           def validate_cross_agent_dispatch(sender_agent_key, agent_key, mentioned, content, channel_id)
             return false unless mentioned
 
@@ -158,6 +206,62 @@ 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
+
+          # Check if this agent is the only bot in the thread (1-on-1 with the human).
+          # Uses the already-fetched channel_history to avoid extra API calls.
+          # channel_history is a formatted string ("Username: message\n...") from fetch_channel_history.
+          # Returns true when no other agent bots have posted in the thread history,
+          # meaning it's safe to skip intent checking (the message is obviously for us).
+          def solo_in_thread?(channel_history, agent_key)
+            return true unless channel_history.is_a?(String) && !channel_history.empty?
+
+            other_bot_usernames = []
+            Gateway.each_bot do |key, info|
+              next if key == agent_key
+              next unless info[:username]
+
+              other_bot_usernames << info[:username]
+            end
+
+            # 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|
+              normalized = name.downcase.gsub(/[^a-z0-9]/, "-")
+              next if normalized == agent_key
+              next if agent_keys.include?(normalized)
+
+              # Only include names that look like agent bots (present in agent registry)
+              next unless defined?(AGENT_REGISTRY) && AGENT_REGISTRY.key?(normalized)
+
+              other_bot_usernames << name
+            end
+
+            return true if other_bot_usernames.empty?
+
+            history_lines = channel_history.split("\n")
+            history_lines.none? do |line|
+              other_bot_usernames.any? { |username| line.start_with?("#{username}: ") }
+            end
+          end
+
           def prepare_content(content, bot_user_id)
             content.gsub(/<@!?#{bot_user_id}>/, "").strip
           end
@@ -276,7 +380,8 @@ module Brainiac
           def route_dispatch(agent_key:, agent_name:, bot_token:, is_bot:, channel_id:, message_id:, message:,
                              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:)
+                             channel_history:, project_key:, project_config:, attachment_paths:,
+                             directly_addressed: false)
             session_key = "discord-#{agent_key}-#{channel_id}-#{message_id}"
             supersede_key = "discord-#{agent_key}-#{channel_id}"
             if session_active?(session_key)
@@ -285,9 +390,12 @@ module Brainiac
             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
+            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)
+                return
+              end
             end
 
             Thread.new do

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Handles cleanup of Discord thread worktrees when threads are archived or deleted.
+      #
+      # When a thread is archived (manually closed or auto-archived due to inactivity)
+      # or deleted, this module looks up the associated worktree in discord_thread_map.json,
+      # verifies it has no uncommitted changes, removes the worktree + branch, and removes
+      # the thread map entry.
+      module ThreadCleanup
+        class << self
+          def handle_archive(data, agent_key, agent_display)
+            thread_id = data["id"]
+            return unless thread_id
+
+            thread_map_key = "#{agent_key}:#{thread_id}"
+
+            entry = Config.thread_map_mutex.synchronize do
+              map = Config.load_thread_map
+              map[thread_map_key]
+            end
+
+            unless entry
+              LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — no worktree tracked, nothing to clean up" if defined?(LOG)
+              return
+            end
+
+            worktree_path = entry["worktree"]
+            branch = entry["branch"]
+            project_key = entry["project"]
+            chat_mode = entry["chat_mode"]
+
+            if chat_mode
+              cleanup_chat_mode_dir(worktree_path, thread_map_key, agent_display, thread_id)
+            else
+              cleanup_worktree(worktree_path, branch, project_key, thread_map_key, agent_display, thread_id)
+            end
+          end
+
+          private
+
+          def cleanup_chat_mode_dir(dir_path, thread_map_key, agent_display, thread_id)
+            if dir_path && File.directory?(dir_path)
+              FileUtils.rm_rf(dir_path)
+              LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — removed chat mode dir #{dir_path}" if defined?(LOG)
+            elsif defined?(LOG)
+              LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — chat mode dir already gone"
+            end
+
+            remove_thread_map_entry(thread_map_key)
+          end
+
+          def cleanup_worktree(worktree_path, branch, project_key, thread_map_key, agent_display, thread_id)
+            unless worktree_path && File.directory?(worktree_path)
+              LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — worktree already removed, cleaning up map entry" if defined?(LOG)
+              remove_thread_map_entry(thread_map_key)
+              return
+            end
+
+            status_output, = Open3.capture3("git", "status", "--porcelain", chdir: worktree_path)
+            unless status_output.strip.empty?
+              if defined?(LOG)
+                LOG.warn "[Discord:#{agent_display}] Thread #{thread_id} archived — " \
+                         "worktree #{worktree_path} has uncommitted changes, skipping cleanup"
+              end
+              return
+            end
+
+            project_config = defined?(PROJECTS) ? PROJECTS[project_key] : nil
+            repo_path = project_config&.dig("repo_path")
+
+            unless repo_path && File.directory?(repo_path)
+              if defined?(LOG)
+                LOG.warn "[Discord:#{agent_display}] Thread #{thread_id} archived — " \
+                         "cannot find repo for project '#{project_key}', removing directory directly"
+              end
+              FileUtils.rm_rf(worktree_path)
+              remove_thread_map_entry(thread_map_key)
+              return
+            end
+
+            begin
+              Open3.capture3("git", "worktree", "remove", worktree_path, "--force", chdir: repo_path)
+              LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — removed worktree #{worktree_path}" if defined?(LOG)
+            rescue StandardError => e
+              LOG.warn "[Discord:#{agent_display}] Failed to remove worktree #{worktree_path}: #{e.message}" if defined?(LOG)
+            end
+
+            if branch
+              begin
+                Open3.capture3("git", "branch", "-D", branch, chdir: repo_path)
+                LOG.info "[Discord:#{agent_display}] Thread #{thread_id} archived — deleted branch #{branch}" if defined?(LOG)
+              rescue StandardError => e
+                LOG.warn "[Discord:#{agent_display}] Failed to delete branch #{branch}: #{e.message}" if defined?(LOG)
+              end
+            end
+
+            remove_thread_map_entry(thread_map_key)
+          end
+
+          def remove_thread_map_entry(thread_map_key)
+            Config.thread_map_mutex.synchronize do
+              map = Config.load_thread_map
+              map.delete(thread_map_key)
+              Config.save_thread_map(map)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Discord
-      VERSION = "0.0.3"
+      VERSION = "0.0.5"
     end
   end
 end

data/lib/brainiac/plugins/discord.rb

@@ -9,6 +9,7 @@ require_relative "discord/api"
 require_relative "discord/delivery"
 require_relative "discord/reactions"
 require_relative "discord/message"
+require_relative "discord/thread_cleanup"
 require_relative "discord/gateway"
 
 module Brainiac
@@ -31,6 +32,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 +49,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.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Andy Davis
@@ -112,6 +112,7 @@ files:
 - lib/brainiac/plugins/discord/metadata.rb
 - lib/brainiac/plugins/discord/prompts.rb
 - lib/brainiac/plugins/discord/reactions.rb
+- lib/brainiac/plugins/discord/thread_cleanup.rb
 - lib/brainiac/plugins/discord/version.rb
 - lib/brainiac_discord.rb
 homepage: https://github.com/stowzilla/brainiac-discord