brainiac 0.0.9 → 0.0.11

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

@@ -1,196 +0,0 @@
-# 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

@@ -1,134 +0,0 @@
-# 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 = agent_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

@@ -1,196 +0,0 @@
-# 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 = agent_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