brainiac-discord 0.0.1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Lightweight metadata for brainiac-discord.
+# Loaded by `brainiac help` without pulling in the full plugin runtime.
+
+require_relative "version"
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Returns true if Discord has at least one bot token configured.
+      def self.configured?
+        registry_file = File.join(ENV.fetch("BRAINIAC_DIR", File.join(Dir.home, ".brainiac")), "agents.json")
+        return false unless File.exist?(registry_file)
+
+        registry = JSON.parse(File.read(registry_file))
+        registry.any? { |_k, v| v.is_a?(Hash) && v.dig("env", "DISCORD_BOT_TOKEN") }
+      rescue StandardError
+        false
+      end
+
+      # Help text shown in `brainiac help` when the plugin is installed.
+      def self.help_text
+        "    brainiac discord <command>    Manage Discord bots (config, token, status, map)"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord prompt templates.
+      #
+      # CHANNEL — Discord-specific rules prepended to every Discord session.
+      # SITUATION — The standard Discord dispatch template with conversation context.
+      module Prompts
+        CHANNEL = <<~PROMPT
+          ## Discord Channel Rules
+
+          ### Mentions
+          Discord does NOT support plain-text @mentions. Writing `@Galen` renders as plain text.
+          To actually mention someone, use the `<@USER_ID>` format. Here are the known IDs:
+          {{DISCORD_MENTION_ROSTER}}
+
+          If you need to mention someone not on this list, just write their name without the @ symbol.
+          Do NOT @mention other agent bots unless the user explicitly asks you to bring them into the conversation.
+          Mentioning another agent triggers an automated dispatch — doing it casually can cause loops.
+
+          ### Formatting
+          Do NOT use HTML formatting. Use plain text or Discord markdown:
+          - ```code blocks``` for code
+          - **bold** for emphasis
+          - *italic* for softer emphasis
+          - > quotes for referencing
+
+          ### Response Delivery
+          You MUST write your response to a file at `{{RESPONSE_FILE}}`.
+          Do NOT respond via stdout — your response will only be delivered if written to this file.
+          Keep it conversational and concise — Discord messages have a 2000 char limit
+          per message, though long responses will be split automatically.
+
+          ### Scope
+          This is a conversational interaction — no card, no PR. You're here to answer questions,
+          discuss code, share knowledge, or help with whatever the user needs.
+
+          **Detect user intent:**
+          - If they're asking you to **implement, fix, build, update, or change** something → do the work
+          - If they're asking questions, discussing ideas, or seeking advice → respond conversationally
+
+          **When doing implementation work:**
+          1. Create a worktree branching from `origin/main` (or the default branch shown in Project Context):
+             `git worktree add -b discord-<topic>-<timestamp> ../<repo>--discord-<topic>-<timestamp> origin/main`
+          2. `cd` into the new worktree directory
+          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)
+
+          **When responding conversationally:**
+          - Answer questions about the codebase, architecture, conventions
+          - Search your brain (knowledge + persona) for relevant context
+          - Read files from registered project repos to investigate questions
+          - Update your knowledge or persona files if the conversation warrants it
+
+          ### GIFs (optional)
+          You can optionally include a GIF in your Discord response to add personality.
+          To find one, search the local GIF API:
+          ```
+          curl -s "http://localhost:4567/api/gif?q=your+search+terms"
+          ```
+          This returns JSON with a `results` array. Each result has a `url` field — paste that
+          URL on its own line in your response and Discord will auto-embed it as an animated GIF.
+
+          **Guidelines:**
+          - GIFs should be RARE — include one in roughly 15% of responses, not more
+          - Default to NO GIF. Only include one when the moment is a genuine zinger — a perfectly landed joke, a dramatic reveal, a celebration that demands visual punctuation, or a response so good it needs the exclamation point of a GIF
+          - Skip GIFs for routine answers, technical implementation work, status updates, or when the tone doesn't call for one
+          - Match the GIF to the emotional tone — celebration, sarcasm, emphasis, humor
+          - Surprise is good — pick GIFs that are unexpected or perfectly timed, not generic
+          - Pick the most relevant result, not just the first one
+          - If the API returns no results or errors, just skip the GIF — don't mention it
+
+          ### Thread Memory (CRITICAL for long conversations)
+          Discord threads drift — your context window only shows recent messages, not the full history.
+          When writing your memory file for a Discord thread session, you MUST include:
+          - The original question/topic that started the thread (from "Original Message" above or your prior memory)
+          - A condensed summary of ALL topics discussed so far, not just this session
+          - Any topic shifts that occurred — what changed and why
+          - 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.
+
+        PROMPT
+
+        SITUATION = <<~'PROMPT'
+          ## Context
+
+          **From:** {{DISCORD_USER}} in #{{CHANNEL_NAME}}
+          {{REPLY_CONTEXT}}**Message:**
+          {{MESSAGE_BODY}}
+
+          {{THREAD_ROOT_CONTEXT}}### Recent Channel History
+          These are the messages immediately before the one above, for conversational context:
+          ```
+          {{CHANNEL_HISTORY}}
+          ```
+
+          {{PROJECT_CONTEXT}}
+
+          **IMPORTANT: Write your response to `{{RESPONSE_FILE}}`. Do NOT reply via stdout.**
+        PROMPT
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Discord
+      # Discord reaction handler.
+      #
+      # Handles MESSAGE_REACTION_ADD events:
+      # - ❌ to cancel an active agent session
+      # - ❔/❓ to peek at the agent's thinking (last 10/20 lines)
+      # - 🧠 to stream the full thinking log to a thread
+      # - Non-reserved emojis logged as feedback to the agent's persona
+      module Reactions
+        class << self
+          def handle(reaction_data, agent_key, bot_token, bot_user_id)
+            channel_id = reaction_data["channel_id"]
+            message_id = reaction_data["message_id"]
+            user_id = reaction_data["user_id"]
+            emoji = reaction_data["emoji"]
+            emoji_name = emoji["name"]
+
+            agent_name = agent_display_name(agent_key) || agent_key.capitalize
+
+            # Ignore reactions from bots (including self)
+            return if user_id == bot_user_id
+
+            case emoji_name
+            when "❔", "❓"
+              handle_thinking_peek(agent_key, agent_name, channel_id, message_id, bot_token, line_count: emoji_name == "❔" ? 10 : 20)
+            when "🧠"
+              handle_thinking_stream(agent_key, agent_name, channel_id, message_id, bot_token)
+            when "❌"
+              handle_cancel(agent_key, agent_name, channel_id, message_id, bot_token)
+            else
+              unless Api::RESERVED_EMOJIS.include?(emoji_name)
+                Thread.new do
+                  log_emoji_feedback(channel_id, message_id, user_id, emoji_name, agent_key, agent_name, bot_token)
+                rescue StandardError => e
+                  LOG.warn "[Discord:#{agent_name}] Feedback logging failed: #{e.message}" if defined?(LOG)
+                end
+              end
+            end
+          end
+
+          private
+
+          # Strip ANSI escape codes and non-ASCII from log output for Discord display.
+          def strip_ansi(text)
+            text.gsub(/\e\[[0-9;]*[a-zA-Z]/, "")
+                .gsub(/\x1b\[[0-9;]*[a-zA-Z]/, "")
+                .gsub(/\e\][0-9;]*.*?(\x07|\e\\)/, "")
+                .gsub(/\e[=>]/, "")
+                .gsub(/\[\?[0-9]+[lh]/, "")
+                .gsub("[K", "")
+                .encode("ASCII", invalid: :replace, undef: :replace, replace: "")
+                .strip
+          end
+
+          def handle_thinking_peek(agent_key, agent_name, channel_id, message_id, bot_token, line_count:)
+            session_key = "discord-#{agent_key}-#{channel_id}-#{message_id}"
+
+            ACTIVE_SESSIONS_MUTEX.synchronize do
+              session_info = ACTIVE_SESSIONS[session_key]
+
+              unless session_info
+                LOG.info "[Discord:#{agent_name}] Thinking peek on #{message_id} but no active session found" if defined?(LOG)
+                return
+              end
+
+              log_file = session_info[:log_file]
+              unless log_file && File.exist?(log_file)
+                LOG.warn "[Discord:#{agent_name}] No log file found for session #{session_key}" if defined?(LOG)
+                Api.send_message(channel_id, "No thinking file found for this session.", token: bot_token, reply_to: message_id)
+                return
+              end
+
+              LOG.info "[Discord:#{agent_name}] Reading last #{line_count} lines from #{log_file}" if defined?(LOG)
+
+              lines = File.readlines(log_file).last(line_count)
+              thinking_output = strip_ansi(lines.join)
+
+              response = "**Last #{line_count} lines:**\n```\n#{thinking_output}\n```"
+              Api.send_message(channel_id, response, token: bot_token, reply_to: message_id)
+            end
+          end
+
+          def handle_thinking_stream(agent_key, agent_name, channel_id, message_id, bot_token)
+            session_key = "discord-#{agent_key}-#{channel_id}-#{message_id}"
+
+            ACTIVE_SESSIONS_MUTEX.synchronize do
+              session_info = ACTIVE_SESSIONS[session_key]
+
+              unless session_info
+                LOG.info "[Discord:#{agent_name}] 🧠 reaction on #{message_id} but no active session found" if defined?(LOG)
+                return
+              end
+
+              log_file = session_info[:log_file]
+              unless log_file && File.exist?(log_file)
+                LOG.warn "[Discord:#{agent_name}] No log file found for session #{session_key}" if defined?(LOG)
+                Api.send_message(channel_id, "No thinking file found for this session.", token: bot_token, reply_to: message_id)
+                return
+              end
+
+              LOG.info "[Discord:#{agent_name}] Creating thread and streaming thinking from #{log_file}" if defined?(LOG)
+
+              thread_response = Api.create_thread(channel_id, message_id, name: "🧠 Thinking Stream", token: bot_token)
+              unless thread_response && thread_response["id"]
+                LOG.error "[Discord:#{agent_name}] Failed to create thread, response: #{thread_response.inspect}" if defined?(LOG)
+                return
+              end
+
+              thread_id = thread_response["id"]
+              stream_thinking_to_thread(log_file, thread_id, bot_token)
+            end
+          end
+
+          def stream_thinking_to_thread(log_file, thread_id, bot_token)
+            thinking_content = strip_ansi(File.read(log_file))
+
+            chunks = []
+            current_chunk = ""
+            thinking_content.lines.each do |line|
+              if current_chunk.length + line.length > 1900
+                chunks << current_chunk
+                current_chunk = line
+              else
+                current_chunk += line
+              end
+            end
+            chunks << current_chunk unless current_chunk.empty?
+
+            chunks.each do |chunk|
+              Api.send_message(thread_id, "```\n#{chunk}\n```", token: bot_token)
+              sleep 0.5
+            end
+          end
+
+          def handle_cancel(agent_key, agent_name, channel_id, message_id, bot_token)
+            session_key = "discord-#{agent_key}-#{channel_id}-#{message_id}"
+
+            ACTIVE_SESSIONS_MUTEX.synchronize do
+              session_info = ACTIVE_SESSIONS[session_key]
+
+              unless session_info
+                LOG.info "[Discord:#{agent_name}] ❌ reaction on #{message_id} but no active session found" if defined?(LOG)
+                return
+              end
+
+              LOG.info "[Discord:#{agent_name}] Cancelling session for message #{message_id} (PID: #{session_info[:pid]})" if defined?(LOG)
+
+              begin
+                Process.kill("KILL", session_info[:pid])
+                LOG.info "[Discord:#{agent_name}] Killed agent process #{session_info[:pid]}" if defined?(LOG)
+              rescue Errno::ESRCH
+                LOG.warn "[Discord:#{agent_name}] Process #{session_info[:pid]} already exited" if defined?(LOG)
+              rescue Errno::EPERM
+                LOG.error "[Discord:#{agent_name}] Permission denied killing process #{session_info[:pid]}" if defined?(LOG)
+              end
+
+              ACTIVE_SESSIONS.delete(session_key)
+
+              begin
+                Api.remove_reaction(channel_id, message_id, "👀", token: bot_token)
+                Api.add_reaction(channel_id, message_id, "🛑", token: bot_token)
+              rescue StandardError => e
+                LOG.warn "[Discord:#{agent_name}] Failed to update reactions: #{e.message}" if defined?(LOG)
+              end
+
+              session_info[:draft_files]&.each { |file| FileUtils.rm_f(file) }
+            end
+          end
+
+          def log_emoji_feedback(channel_id, message_id, user_id, emoji_name, agent_key, agent_name, bot_token)
+            msg = Api.fetch_message(channel_id, message_id, token: bot_token, log_errors: false)
+            return unless msg&.dig("author", "bot")
+
+            bot_uid = Gateway.bot_user_id(agent_key)
+            return unless bot_uid && msg.dig("author", "id") == bot_uid
+
+            reactor = respond_to?(:find_user_by_discord_id) ? find_user_by_discord_id(user_id) : nil
+            reactor_name = reactor ? reactor["canonical_name"] : user_id
+
+            snippet = (msg["content"] || "")[0, 80].tr("\n", " ").strip
+            snippet = "#{snippet}..." if (msg["content"] || "").length > 80
+
+            feedback_dir = File.join(persona_dir_for(agent_name), "people")
+            FileUtils.mkdir_p(feedback_dir)
+            feedback_file = File.join(feedback_dir, "#{reactor_name.downcase.gsub(/[^a-z0-9]/, "-")}-feedback.md")
+
+            timestamp = Time.now.strftime("%Y-%m-%d %H:%M")
+            entry = "- #{timestamp} #{emoji_name} on: \"#{snippet}\" (channel: #{channel_id})\n"
+
+            if File.exist?(feedback_file)
+              File.open(feedback_file, "a") { |f| f.write(entry) }
+            else
+              File.write(feedback_file, "# Feedback from #{reactor_name}\n\n## Reaction Log\n#{entry}")
+            end
+
+            LOG.info "[Discord:#{agent_name}] Logged #{emoji_name} feedback from #{reactor_name} on message #{message_id}" if defined?(LOG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Brainiac
+  module Plugins
+    module Discord
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/brainiac/plugins/discord.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "discord/version"
+require_relative "discord/metadata"
+require_relative "discord/cli"
+require_relative "discord/config"
+require_relative "discord/prompts"
+require_relative "discord/api"
+require_relative "discord/delivery"
+require_relative "discord/reactions"
+require_relative "discord/message"
+require_relative "discord/gateway"
+
+module Brainiac
+  module Plugins
+    module Discord
+      class << self
+        # Called by Brainiac plugin system during server startup.
+        #
+        # @param app [Sinatra::Application] The running Brainiac server
+        def register(app)
+          # Load Discord config
+          Brainiac::Plugins::Discord::Config.load!
+
+          # Register channel prompt
+          Brainiac.register_channel_prompt(:discord, Brainiac::Plugins::Discord::Prompts::CHANNEL)
+
+          # Register as notification provider
+          register_notification_handler!
+
+          # Register crash handler
+          register_crash_handler!
+
+          # Start all per-agent Discord bot gateway connections
+          Brainiac::Plugins::Discord::Gateway.start_all!
+
+          # Start draft delivery poller
+          Brainiac::Plugins::Discord::Delivery.start_poller!
+
+          # Set up API routes
+          setup_routes(app)
+
+          LOG.info "[Discord] Plugin registered (#{Brainiac::Plugins::Discord::Gateway.bot_count} bots)"
+        end
+
+        private
+
+        def register_notification_handler!
+          Brainiac.on(:notify) do |ctx|
+            next unless ctx[:channel].to_s == "discord"
+
+            target = ctx[:target]
+            message = ctx[:message]
+            agent = ctx[:agent]
+
+            agent_key = agent&.downcase&.gsub(/[^a-z0-9-]/, "-")
+            token = Gateway.bot_token(agent_key) ||
+                    Gateway.discord_bot_tokens[agent_key] ||
+                    Gateway.discord_bot_tokens.values.first
+            next unless token && target
+
+            # 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)
+            elsif ctx[:forum_reply_to_latest] && Api.forum_channel?(target, token: token)
+              latest = Api.find_latest_forum_thread(target, token: token)
+              if latest
+                Api.send_long_message(latest["id"], message, token: token)
+              else
+                Api.send_long_message(target, message, token: token)
+              end
+            else
+              Api.send_long_message(target, message, token: token)
+            end
+
+            :discord # Signal that we handled it
+          end
+        end
+
+        def register_crash_handler!
+          Brainiac.on(:agent_crashed) do |ctx|
+            next unless %i[discord cron].include?(ctx[:source])
+
+            source_context = ctx[:source_context] || {}
+            channel_id = source_context[:channel_id] || source_context.dig(:job, :notify_target) || source_context.dig(:job, :discord_channel_id)
+            next unless channel_id
+
+            bot_token = source_context[:bot_token]
+            unless bot_token
+              agent_key = source_context.dig(:job, :agent)&.downcase&.gsub(/[^a-z0-9-]/, "-")
+              bot_token = Gateway.bot_token(agent_key) || Gateway.discord_bot_tokens.values.first
+            end
+            next unless bot_token
+
+            snippet = ctx[:snippet]
+            snippet_block = snippet ? "\n```\n#{snippet[-1500..]}\n```" : ""
+            message = "💥 **#{ctx[:agent_name]} crashed** (exit code #{ctx[:exit_status]})\nLog: `#{ctx[:log_file]}`#{snippet_block}"
+
+            Api.send_long_message(channel_id, message, token: bot_token, reply_to: source_context[:message_id])
+            :discord
+          end
+        end
+
+        def setup_routes(app)
+          app.get "/api/discord" do
+            content_type :json
+            Brainiac::Plugins::Discord::Gateway.bots_status.to_json
+          end
+
+          app.get "/api/gif" do
+            content_type :json
+            query = params["q"]
+            halt 400, { error: "missing q param" }.to_json unless query && !query.empty?
+
+            results = Brainiac::Plugins::Discord::Api.search_gif(query)
+            { results: results }.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainiac_discord.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Brainiac Discord Plugin — entry point loaded by RubyGems.
+require_relative "brainiac/plugins/discord"

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: brainiac-discord
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Davis
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: brainiac
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.75'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.25'
+description: Full Discord integration for Brainiac — per-agent bot gateway connections,
+  message handling, session supersede, draft delivery, reaction handlers (cancel,
+  thinking peek, feedback logging), worktree management, and GIF support. Uses Brainiac's
+  hook system for lifecycle integration.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/brainiac/plugins/discord.rb
+- lib/brainiac/plugins/discord/api.rb
+- lib/brainiac/plugins/discord/cli.rb
+- lib/brainiac/plugins/discord/config.rb
+- lib/brainiac/plugins/discord/delivery.rb
+- lib/brainiac/plugins/discord/gateway.rb
+- lib/brainiac/plugins/discord/message.rb
+- lib/brainiac/plugins/discord/metadata.rb
+- lib/brainiac/plugins/discord/prompts.rb
+- lib/brainiac/plugins/discord/reactions.rb
+- lib/brainiac/plugins/discord/version.rb
+- lib/brainiac_discord.rb
+homepage: https://github.com/stowzilla/brainiac-discord
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Discord bot plugin for Brainiac
+test_files: []