brainiac 0.0.6 → 0.0.7

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# Discord REST API helpers.
+#
+# Low-level HTTP methods and convenience wrappers for the Discord v10 API.
+# Used by the Discord handler itself, but also by GitHub (deploy notifications)
+# and Zoho (email notifications).
+
+DISCORD_API_BASE = "https://discord.com/api/v10"
+
+# Emojis reserved for brainiac functionality — not treated as feedback
+RESERVED_EMOJIS = %w[👀 ❌ 🛑 🚫 ⚠️ ⏳ 😶 ❔ ❓ 🧠].freeze
+
+def discord_api(method, path, token:, body: nil, log_errors: true)
+  uri = URI("#{DISCORD_API_BASE}#{path}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = true
+
+  req = case method
+        when :get    then Net::HTTP::Get.new(uri)
+        when :post   then Net::HTTP::Post.new(uri)
+        when :put    then Net::HTTP::Put.new(uri)
+        when :delete then Net::HTTP::Delete.new(uri)
+        end
+
+  req["Authorization"] = "Bot #{token}"
+  req["Content-Type"] = "application/json"
+  req.body = body.to_json if body
+
+  response = http.request(req)
+
+  if response.code.to_i == 429
+    retry_after = JSON.parse(response.body)["retry_after"] || 1
+    LOG.warn "Discord rate limited, waiting #{retry_after}s"
+    sleep retry_after
+    return discord_api(method, path, token: token, body: body, log_errors: log_errors)
+  end
+
+  LOG.error "Discord API error (#{method} #{path}): HTTP #{response.code} - #{response.body}" if response.code.to_i >= 400 && log_errors
+
+  JSON.parse(response.body) unless response.body.nil? || response.body.empty?
+rescue StandardError => e
+  LOG.error "Discord API error (#{method} #{path}): #{e.message}" if log_errors
+  nil
+end
+
+# --- Channel & Message Operations ---
+
+def fetch_discord_channel_history(channel_id, before_message_id, token:, limit: 10)
+  messages = discord_api(:get, "/channels/#{channel_id}/messages?before=#{before_message_id}&limit=#{limit}", token: token)
+
+  all_messages = messages.is_a?(Array) ? messages : []
+
+  # If we're in a thread, check if the oldest message is a THREAD_STARTER_MESSAGE (type 21).
+  # These messages have no content but point to the original message via referenced_message.
+  # We need to include that original message for full context.
+  if all_messages.any?
+    oldest = all_messages.last # API returns newest-first
+    all_messages << oldest["referenced_message"] if oldest && oldest["type"] == 21 && oldest["referenced_message"]
+  end
+
+  return "" if all_messages.empty?
+
+  # Messages come newest-first from the API, reverse for chronological order
+  lines = all_messages.reverse.filter_map do |msg|
+    author = msg.dig("author", "username") || "unknown"
+    content = msg["content"]&.strip || ""
+    next if content.empty?
+
+    "#{author}: #{content}"
+  end
+
+  return "" if lines.empty?
+
+  lines.join("\n")
+rescue StandardError => e
+  LOG.warn "Failed to fetch channel history: #{e.message}"
+  ""
+end
+
+def fetch_channel_info(channel_id, token:)
+  discord_api(:get, "/channels/#{channel_id}", token: token)
+end
+
+def fetch_discord_message(channel_id, message_id, token:, log_errors: true)
+  discord_api(:get, "/channels/#{channel_id}/messages/#{message_id}", token: token, log_errors: log_errors)
+end
+
+def fetch_guild_member(guild_id, user_id, token:)
+  discord_api(:get, "/guilds/#{guild_id}/members/#{user_id}", token: token)
+end
+
+# --- Messaging ---
+
+def send_discord_message(channel_id, content, token:, reply_to: nil)
+  body = { content: content }
+  body[:message_reference] = { message_id: reply_to } if reply_to
+  result = discord_api(:post, "/channels/#{channel_id}/messages", token: token, body: body)
+  if result && result["id"]
+    LOG.info "[Discord] Message posted successfully to channel #{channel_id}, message_id: #{result["id"]}"
+  else
+    LOG.error "[Discord] Failed to post message to channel #{channel_id}, result: #{result.inspect}"
+  end
+  result
+end
+
+def send_long_discord_message(channel_id, content, token:, reply_to: nil)
+  if content.length <= 2000
+    send_discord_message(channel_id, content, token: token, reply_to: reply_to)
+    return
+  end
+
+  chunks = []
+  remaining = content
+  while remaining.length.positive?
+    if remaining.length <= 2000
+      chunks << remaining
+      remaining = ""
+    else
+      split_at = remaining.rindex("\n", 1990) || 1990
+      chunks << remaining[0...split_at]
+      remaining = remaining[split_at..].lstrip
+    end
+  end
+
+  chunks.each_with_index do |chunk, i|
+    send_discord_message(channel_id, chunk, token: token, reply_to: i.zero? ? reply_to : nil)
+    sleep 0.5
+  end
+end
+
+def send_discord_typing(channel_id, token:)
+  discord_api(:post, "/channels/#{channel_id}/typing", token: token)
+end
+
+# --- Reactions ---
+
+def add_discord_reaction(channel_id, message_id, emoji, token:)
+  encoded = URI.encode_www_form_component(emoji)
+  discord_api(:put, "/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me", token: token)
+end
+
+def remove_discord_reaction(channel_id, message_id, emoji, token:)
+  encoded = URI.encode_www_form_component(emoji)
+  discord_api(:delete, "/channels/#{channel_id}/messages/#{message_id}/reactions/#{encoded}/@me", token: token)
+end
+
+# --- Threads & Forums ---
+
+def create_discord_thread(channel_id, message_id, name:, token:)
+  thread_name = name.length > 100 ? "#{name[0..96]}..." : name
+  discord_api(:post, "/channels/#{channel_id}/messages/#{message_id}/threads", token: token, body: {
+                name: thread_name,
+                auto_archive_duration: 1440
+              })
+end
+
+def forum_channel?(channel_id, token:)
+  info = fetch_channel_info(channel_id, token: token)
+  info && info["type"] == 15
+end
+
+def find_latest_forum_thread(channel_id, token:)
+  channel_info = fetch_channel_info(channel_id, token: token)
+  return nil unless channel_info && channel_info["guild_id"]
+
+  guild_id = channel_info["guild_id"]
+  result = discord_api(:get, "/guilds/#{guild_id}/threads/active", token: token)
+  return nil unless result && result["threads"]
+
+  forum_threads = result["threads"]
+                  .select { |t| t["parent_id"] == channel_id }
+                  .sort_by { |t| t["id"].to_i }
+                  .reverse
+
+  return nil if forum_threads.empty?
+
+  latest = forum_threads.first
+  LOG.info "[Discord] Found latest forum thread: #{latest["id"]} (#{latest["name"]}) in channel #{channel_id}"
+  latest
+end
+
+def create_forum_post(channel_id, title:, content:, token:)
+  thread_name = title.length > 100 ? "#{title[0..96]}..." : title
+  result = discord_api(:post, "/channels/#{channel_id}/threads", token: token, body: {
+                         name: thread_name,
+                         message: { content: content },
+                         auto_archive_duration: 1440
+                       })
+  if result && result["id"]
+    LOG.info "[Discord] Forum post created in channel #{channel_id}, thread_id: #{result["id"]}"
+  else
+    LOG.error "[Discord] Failed to create forum post in channel #{channel_id}, result: #{result.inspect}"
+  end
+  result
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Discord configuration and shared state.
+#
+# Constants, config loading, and thread map persistence used across
+# all Discord sub-modules.
+
+DISCORD_CONFIG_FILE = File.join(BRAINIAC_DIR, "discord.json")
+
+# Discord thread worktree map: tracks worktrees created for Discord thread conversations.
+# Keyed by "agent_key:channel_id" → { worktree, branch, project, created_at }
+# Persisted to disk so sessions survive restarts.
+DISCORD_THREAD_MAP_FILE = File.join(BRAINIAC_DIR, "discord_thread_map.json")
+DISCORD_THREAD_MAP_MUTEX = Mutex.new
+
+def load_discord_config
+  default = { "channel_mappings" => {}, "authorized_role_ids" => [], "authorized_user_ids" => [] }
+  return default unless File.exist?(DISCORD_CONFIG_FILE)
+
+  JSON.parse(File.read(DISCORD_CONFIG_FILE))
+rescue JSON::ParserError => e
+  LOG.error "Failed to parse discord config: #{e.message}"
+  default
+end
+
+DISCORD_CONFIG = load_discord_config
+
+def reload_discord_config!
+  DISCORD_CONFIG.replace(load_discord_config)
+end
+
+# Collect all agent Discord bot tokens from the registry.
+# Returns { "galen" => "token...", "glados" => "token..." }
+def discord_bot_tokens
+  tokens = {}
+  AGENT_REGISTRY.each do |key, entry|
+    next unless entry.is_a?(Hash)
+
+    token = (entry["env"] || {})["DISCORD_BOT_TOKEN"]
+    next unless token
+
+    tokens[key] = token
+  end
+  tokens
+end
+
+# --- Thread Map Persistence ---
+
+def load_discord_thread_map
+  return {} unless File.exist?(DISCORD_THREAD_MAP_FILE)
+
+  JSON.parse(File.read(DISCORD_THREAD_MAP_FILE))
+rescue JSON::ParserError
+  {}
+end
+
+def save_discord_thread_map(map)
+  File.write(DISCORD_THREAD_MAP_FILE, JSON.pretty_generate(map))
+end
+
+# --- Channel/Project Routing ---
+
+def find_project_for_discord_channel(channel_id)
+  mapping = DISCORD_CONFIG.dig("channel_mappings", channel_id)
+
+  unless mapping
+    default_project = DISCORD_CONFIG["default_project"]
+    mapping = { "project" => default_project } if default_project
+  end
+
+  return nil unless mapping
+
+  project_key = mapping["project"]
+  project_config = PROJECTS[project_key]
+  return nil unless project_config
+
+  [project_key, project_config, mapping]
+end
+
+# Find the root message for a conversation thread.
+# Walks back through message_reference chain to find the original message.
+def find_root_message(message, channel_id, bot_token)
+  current_msg = message
+  visited = Set.new
+  max_depth = 20
+  walked = false
+
+  max_depth.times do
+    msg_id = current_msg["id"]
+    return { id: msg_id, content: nil, author: nil } if visited.include?(msg_id)
+
+    visited << msg_id
+
+    ref = current_msg["message_reference"]
+    break unless ref
+
+    ref_msg_id = ref["message_id"]
+    ref_channel = ref["channel_id"] || channel_id
+    break unless ref_msg_id
+
+    referenced = discord_api(:get, "/channels/#{ref_channel}/messages/#{ref_msg_id}", token: bot_token)
+    break unless referenced
+
+    current_msg = referenced
+    walked = true
+  end
+
+  {
+    id: current_msg["id"],
+    content: walked ? current_msg["content"]&.strip : nil,
+    author: walked ? current_msg.dig("author", "username") : nil
+  }
+end
+
+# Build a Discord mention roster so the agent can @mention people and other bots.
+def discord_mention_roster
+  lines = []
+
+  DISCORD_BOTS_MUTEX.synchronize do
+    DISCORD_BOTS.each do |agent_key, info|
+      next unless info[:user_id]
+
+      display = fizzy_display_name(agent_key) || agent_key.capitalize
+      lines << "  - #{display}: `<@#{info[:user_id]}>`"
+    end
+  end
+
+  user_mappings = DISCORD_CONFIG["user_mappings"] || {}
+  user_mappings.each do |name, discord_id|
+    lines << "  - #{name}: `<@#{discord_id}>`"
+  end
+
+  lines.join("\n")
+end

data/lib/brainiac/handlers/discord/delivery.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# Discord draft delivery system.
+#
+# Response files land in draft/ with a .meta.json sidecar containing delivery info.
+# After successful posting, both files move to posted/.
+# A poller thread recovers orphaned drafts (e.g. after a server restart).
+
+DISCORD_DRAFT_DIR  = File.join(BRAINIAC_DIR, "tmp", "discord", "draft")
+DISCORD_POSTED_DIR = File.join(BRAINIAC_DIR, "tmp", "discord", "posted")
+FileUtils.mkdir_p(DISCORD_DRAFT_DIR)
+FileUtils.mkdir_p(DISCORD_POSTED_DIR)
+
+# Shared thread map: when multiple agents are mentioned in the same message,
+# the first to deliver creates the thread and stores its ID here so the rest
+# post into the same thread instead of creating duplicates.
+DISCORD_SHARED_THREADS = {}
+DISCORD_SHARED_THREADS_MUTEX = Mutex.new
+
+# Shared logic for posting a draft response file to Discord and moving it to posted/.
+# Used by both the monitoring thread (happy path) and the poller (recovery path).
+def deliver_discord_draft(response_file, meta_file)
+  return false unless File.exist?(meta_file)
+
+  lock_file = "#{meta_file}.lock"
+  begin
+    File.open(lock_file, File::CREAT | File::EXCL | File::WRONLY) {} # rubocop:disable Lint/EmptyBlock
+  rescue Errno::EEXIST
+    return false
+  end
+
+  meta = JSON.parse(File.read(meta_file))
+  bot_token = resolve_bot_token(meta["agent_key"], meta["agent_name"])
+
+  unless bot_token
+    FileUtils.rm_f(lock_file)
+    return false
+  end
+
+  unless File.exist?(response_file)
+    FileUtils.rm_f(lock_file)
+    return false
+  end
+
+  deliver_response_content(response_file, meta, bot_token)
+  archive_delivered_draft(response_file, meta_file, lock_file, meta["agent_name"])
+  true
+rescue StandardError => e
+  LOG.error "[Discord] Failed to deliver draft #{meta_file}: #{e.message}"
+  File.delete(lock_file) if lock_file && File.exist?(lock_file)
+  false
+end
+
+def resolve_bot_token(agent_key, agent_name)
+  token = DISCORD_BOTS_MUTEX.synchronize { DISCORD_BOTS.dig(agent_key, :token) }
+  token ||= (AGENT_REGISTRY.dig(agent_key, "env") || {})["DISCORD_BOT_TOKEN"]
+  LOG.warn "[Discord:#{agent_name}] No bot token found for #{agent_key}, cannot deliver draft" unless token
+  token
+end
+
+def deliver_response_content(response_file, meta, bot_token)
+  channel_id = meta["channel_id"]
+  message_id = meta["message_id"]
+  agent_key = meta["agent_key"]
+  agent_name = meta["agent_name"]
+  response = File.read(response_file).strip
+
+  if response.empty?
+    add_discord_reaction(channel_id, message_id, "😶", token: bot_token) if message_id
+    send_discord_message(channel_id, "_#{agent_name} had nothing to say._", token: bot_token)
+  elsif meta["is_dm"] || meta["is_thread"] || message_id.nil?
+    deliver_to_dm_or_forum(response, channel_id, message_id, agent_name, meta, bot_token)
+  else
+    deliver_to_channel_thread(response, channel_id, message_id, agent_key, agent_name, meta["clean_content"] || "", bot_token)
+  end
+end
+
+def archive_delivered_draft(response_file, meta_file, lock_file, agent_name)
+  FileUtils.mv(response_file, File.join(DISCORD_POSTED_DIR, File.basename(response_file))) if File.exist?(response_file)
+  FileUtils.mv(meta_file, File.join(DISCORD_POSTED_DIR, File.basename(meta_file)))
+  FileUtils.rm_f(lock_file)
+  LOG.info "[Discord:#{agent_name}] Draft delivered and moved to posted/"
+end
+
+# --- Delivery to DMs, threads, and forum channels ---
+
+def deliver_to_dm_or_forum(response, channel_id, message_id, agent_name, meta, bot_token)
+  if message_id.nil? && forum_channel?(channel_id, token: bot_token)
+    title = meta["forum_title"] || "#{agent_name} — #{Time.now.strftime("%b %d, %Y")}"
+    if meta["forum_reply_to_latest"]
+      latest_thread = find_latest_forum_thread(channel_id, token: bot_token)
+      if latest_thread
+        send_long_discord_message(latest_thread["id"], response, token: bot_token)
+      else
+        LOG.warn "[Discord:#{agent_name}] No existing thread found, creating new forum post"
+        create_forum_post(channel_id, title: title, content: response, token: bot_token)
+      end
+    else
+      create_forum_post(channel_id, title: title, content: response, token: bot_token)
+    end
+  else
+    send_long_discord_message(channel_id, response, token: bot_token)
+  end
+end
+
+# --- Delivery to channel messages (creates or joins a thread) ---
+
+def deliver_to_channel_thread(response, channel_id, message_id, agent_key, agent_name, clean_content, bot_token)
+  thread_id = nil
+  created_thread = false
+
+  DISCORD_SHARED_THREADS_MUTEX.synchronize do
+    thread_id = DISCORD_SHARED_THREADS[message_id]
+
+    # Tier 2: Ask Discord if a thread already exists on this message.
+    unless thread_id
+      original_msg = discord_api(:get, "/channels/#{channel_id}/messages/#{message_id}", token: bot_token)
+      if original_msg&.dig("thread", "id")
+        thread_id = original_msg["thread"]["id"]
+        DISCORD_SHARED_THREADS[message_id] = thread_id
+        LOG.info "[Discord:#{agent_name}] Discovered existing thread #{thread_id} on message #{message_id} via API"
+      end
+    end
+
+    # Tier 3: No thread exists anywhere — create one.
+    unless thread_id
+      display_name = fizzy_display_name(agent_key)
+      thread = create_discord_thread(channel_id, message_id, name: "#{display_name}: #{clean_content[0..80]}", token: bot_token)
+      if thread && thread["id"]
+        thread_id = thread["id"]
+        DISCORD_SHARED_THREADS[message_id] = thread_id
+        created_thread = true
+        LOG.info "[Discord:#{agent_name}] Created shared thread #{thread_id} for message #{message_id}"
+      end
+    end
+  end
+
+  if thread_id
+    LOG.info "[Discord:#{agent_name}] Joining shared thread #{thread_id} for message #{message_id}" unless created_thread
+
+    # Propagate dispatch depth to the thread
+    parent_depth_key = "discord-#{channel_id}"
+    thread_depth_key = "discord-#{thread_id}"
+    parent_info = AGENT_DISPATCH_DEPTH[parent_depth_key]
+    unless AGENT_DISPATCH_DEPTH[thread_depth_key]
+      if parent_info
+        AGENT_DISPATCH_DEPTH[thread_depth_key] = { count: 0, last_human_at: parent_info[:last_human_at] }
+        LOG.info "[Discord:#{agent_name}] Propagated dispatch depth from channel #{channel_id} to thread #{thread_id}"
+      else
+        record_human_comment(thread_depth_key)
+      end
+    end
+
+    send_discord_typing(thread_id, token: bot_token)
+    send_long_discord_message(thread_id, response, token: bot_token)
+  else
+    LOG.warn "[Discord:#{agent_name}] Thread creation failed, falling back to reply"
+    send_long_discord_message(channel_id, response, token: bot_token, reply_to: message_id)
+  end
+end
+
+# --- Draft Poller ---
+
+DISCORD_DRAFT_POLLER_INTERVAL = 5   # seconds
+DISCORD_DRAFT_MIN_AGE = 30          # seconds — don't race the monitoring thread
+
+def start_discord_draft_poller
+  Thread.new do
+    LOG.info "[Discord] Draft poller started, checking #{DISCORD_DRAFT_DIR} every #{DISCORD_DRAFT_POLLER_INTERVAL}s"
+    loop do
+      sleep DISCORD_DRAFT_POLLER_INTERVAL
+      begin
+        # Clean up stale lock files (older than 60s) left by crashed deliveries
+        Dir.glob(File.join(DISCORD_DRAFT_DIR, "*.lock")).each do |lock_file|
+          File.delete(lock_file) if (Time.now - File.mtime(lock_file)) > 60
+        end
+
+        Dir.glob(File.join(DISCORD_DRAFT_DIR, "*.meta.json")).each do |meta_file|
+          next if (Time.now - File.mtime(meta_file)) < DISCORD_DRAFT_MIN_AGE
+
+          response_file = if meta_file.end_with?(".md.meta.json")
+                            meta_file.sub(".md.meta.json", ".md")
+                          else
+                            meta_file.sub(".meta.json", ".md")
+                          end
+          next unless File.exist?(response_file)
+
+          LOG.info "[Discord] Poller recovering orphaned draft: #{File.basename(meta_file)}"
+          deliver_discord_draft(response_file, meta_file)
+        end
+      rescue StandardError => e
+        LOG.error "[Discord] Draft poller error: #{e.message}"
+      end
+    end
+  end
+end