brainiac-discord 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdd8beafe4070560e4caaaa465d2b1e9dde33defa1b7fdc429467864776d3c21
-  data.tar.gz: 8714538569c7c1211a93ffa567401fe54197ce975fb3946e1524550f67cacb97
+  metadata.gz: 5edd0068ecc82d20372d269791ff8e750fcec8106f4adcc99fdef3c252e03ada
+  data.tar.gz: b30c999fc3497d7608463975a3d9f4a8c09b135e3d7bc9da1099b6a5306594c2
 SHA512:
-  metadata.gz: a072c85e99b507dc4cdf65ec04cb9ed1d83e3ef22ef6ba77bd2866b7e04d947920cd607e087be3c93b06d362ef2e94127903e5087b8e9b7a85c456be72684b6f
-  data.tar.gz: 481b0308e707c86fddc515ba26a079bb23c31bb1f0f0f42da00cc7d798af52a24f6f8ea40f75356675f856f037b4e7dafa4174e1d62589569379bdc36e26f401
+  metadata.gz: f65f1deefed415c9b3a038162ad6c59714f2677c9ce8ec201e880ce9ae9b159571cb4910a7515268d0e09ad262e69011ea6f7b1c40471bc846ea5f84fa74d366
+  data.tar.gz: 23ba4bda9f6eb4e9797e6724ad57f12908da3176f116eacdaa11f8b5c3462647180cb8c0a1a1766c00ac12de49c2216e8fdf84da9ad719dcde0bae42307851f9

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

@@ -295,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
@@ -303,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,7 +24,8 @@ 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)
@@ -36,6 +37,10 @@ module Brainiac
                                     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
 
             clean_content = prepare_content(content, bot_user_id)
@@ -62,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,
@@ -70,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
 
@@ -179,6 +224,44 @@ module Brainiac
             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
@@ -297,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)
@@ -306,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.4"
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-discord
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  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