brainiac 0.0.5 → 0.0.7

data/lib/brainiac/planning.rb

@@ -41,7 +41,7 @@ end
 def finalize_plan(card_id:, card_number:, agent_name:, project_key:, repo_path:)
   memory_file = File.join(memory_dir_for(agent_name), "card-#{card_id}.md")
   unless File.exist?(memory_file)
-    LOG.error "[Planning] Cannot finalize plan — no memory file found for card #{card_id}"
+    LOG.warn "[Planning] Cannot finalize plan — no memory file found for card #{card_id}"
     return { success: false, error: "No memory file found" }
   end
 
@@ -60,7 +60,7 @@ def finalize_plan(card_id:, card_number:, agent_name:, project_key:, repo_path:)
   # The agent should have already written the plan to the file during its session.
   # This function just validates it exists and creates Fizzy steps.
   unless File.exist?(plan_file)
-    LOG.error "[Planning] Plan file not found at #{plan_file}"
+    LOG.warn "[Planning] Plan file not found at #{plan_file}"
     return { success: false, error: "Plan file not generated by agent" }
   end
 

data/lib/brainiac/plugins.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Plugin system for Brainiac.
+#
+# Plugins are distributed as gems named `brainiac-<name>` (e.g. brainiac-whatsapp).
+# Each gem exposes a module at `Brainiac::Plugins::<Name>` that responds to `.register(app)`
+# where `app` is the Sinatra application instance.
+#
+# Installed plugins are tracked in ~/.brainiac/plugins.json so the receiver
+# knows which gems to require at startup.
+
+PLUGINS_FILE = File.join(BRAINIAC_DIR, "plugins.json")
+
+def load_plugins_config
+  return { "plugins" => [] } unless File.exist?(PLUGINS_FILE)
+
+  JSON.parse(File.read(PLUGINS_FILE))
+rescue JSON::ParserError => e
+  LOG.error "Failed to parse plugins.json: #{e.message}"
+  { "plugins" => [] }
+end
+
+def save_plugins_config(config)
+  FileUtils.mkdir_p(BRAINIAC_DIR)
+  File.write(PLUGINS_FILE, JSON.pretty_generate(config))
+end
+
+PLUGINS_CONFIG = load_plugins_config
+
+# Returns the list of installed plugin names (e.g. ["whatsapp", "slack"])
+def installed_plugins
+  (PLUGINS_CONFIG["plugins"] || []).map { |p| p.is_a?(Hash) ? p["name"] : p.to_s }
+end
+
+# Load all installed plugin gems and call their register hooks.
+# Called once during server startup, after core handlers are loaded.
+def load_plugins!(app)
+  installed_plugins.each do |name|
+    gem_name = "brainiac-#{name}"
+    begin
+      require gem_name
+      plugin_module = resolve_plugin_module(name)
+      if plugin_module.respond_to?(:register)
+        plugin_module.register(app)
+        LOG.info "[Plugins] Loaded #{gem_name}"
+      else
+        LOG.warn "[Plugins] #{gem_name} loaded but no register method found"
+      end
+    rescue LoadError => e
+      LOG.error "[Plugins] Could not load #{gem_name}: #{e.message}"
+      LOG.error "[Plugins]   Is the gem installed? Run: gem install #{gem_name}"
+    rescue StandardError => e
+      LOG.error "[Plugins] Error registering #{gem_name}: #{e.message}"
+      LOG.error "[Plugins]   #{e.backtrace.first(3).join("\n  ")}"
+    end
+  end
+end
+
+# Resolve the plugin module for a given name.
+# Tries Brainiac::Plugins::Whatsapp, Brainiac::Plugins::WhatsApp, etc.
+def resolve_plugin_module(name)
+  return nil unless defined?(Brainiac::Plugins)
+
+  # Try PascalCase (e.g. "whatsapp" -> "Whatsapp", "test-widget" -> "TestWidget")
+  pascal = name.split(/[-_]/).map(&:capitalize).join
+  return Brainiac::Plugins.const_get(pascal) if Brainiac::Plugins.const_defined?(pascal)
+
+  # Try case-insensitive match (e.g. "WhatsApp" if the gem defines it that way)
+  Brainiac::Plugins.constants.each do |const|
+    return Brainiac::Plugins.const_get(const) if const.to_s.downcase == name.downcase
+  end
+
+  nil
+end
+
+# Install a plugin gem and register it in plugins.json.
+# rubocop:disable Naming/PredicateMethod
+def install_plugin(name, version: nil)
+  gem_name = "brainiac-#{name}"
+
+  if installed_plugins.include?(name)
+    puts "Plugin '#{name}' is already installed."
+    return false
+  end
+
+  puts "Installing #{gem_name}..."
+  install_cmd = ["gem", "install", gem_name]
+  install_cmd.push("--version", version) if version
+
+  stdout, stderr, status = Open3.capture3(*install_cmd)
+  unless status.success?
+    puts "Failed to install #{gem_name}:"
+    puts stderr.empty? ? stdout : stderr
+    return false
+  end
+  puts stdout unless stdout.strip.empty?
+
+  config = load_plugins_config
+  config["plugins"] ||= []
+  entry = { "name" => name, "gem" => gem_name, "installed_at" => Time.now.iso8601 }
+  entry["version"] = version if version
+  config["plugins"] << entry
+  save_plugins_config(config)
+
+  puts "✓ Installed plugin '#{name}' (#{gem_name})"
+  puts "  Restart the server to activate: brainiac restart"
+  true
+end
+
+# Uninstall a plugin gem and remove from plugins.json
+def uninstall_plugin(name)
+  gem_name = "brainiac-#{name}"
+
+  unless installed_plugins.include?(name)
+    puts "Plugin '#{name}' is not installed."
+    return false
+  end
+
+  config = load_plugins_config
+  config["plugins"].reject! { |p| (p.is_a?(Hash) ? p["name"] : p.to_s) == name }
+  save_plugins_config(config)
+
+  puts "Removed plugin '#{name}' from Brainiac."
+  puts "  The gem #{gem_name} is still installed system-wide."
+  puts "  To fully remove: gem uninstall #{gem_name}"
+  puts "  Restart the server to apply: brainiac restart"
+  true
+end
+# rubocop:enable Naming/PredicateMethod

data/lib/brainiac/restart.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Brainiac self-restart logic.
+#
+# When an agent works on brainiac itself (modifies code), a restart is queued.
+# A background thread checks every 30s and only restarts when no other agents
+# are running, preventing mid-session kills.
+#
+# This is NOT Discord-specific — it was previously in the Discord handler
+# because Discord agents trigger restarts most often, but any source can queue one.
+
+BRAINIAC_RESTART_STATE = { queued: false, triggered_by: nil }
+BRAINIAC_RESTART_MUTEX = Mutex.new
+
+def queue_brainiac_restart(agent_name)
+  BRAINIAC_RESTART_MUTEX.synchronize do
+    unless BRAINIAC_RESTART_STATE[:queued]
+      BRAINIAC_RESTART_STATE[:queued] = true
+      BRAINIAC_RESTART_STATE[:triggered_by] = agent_name
+      LOG.info "[Brainiac] #{agent_name} queued a restart — will execute when all agents finish"
+    end
+  end
+end
+
+# Send a Discord notification about brainiac restart/startup using any available bot token.
+def send_restart_notification(message)
+  channel_id = DISCORD_CONFIG["notification_channel_id"]
+  return unless channel_id
+
+  tokens = discord_bot_tokens
+  triggered_by = BRAINIAC_RESTART_MUTEX.synchronize { BRAINIAC_RESTART_STATE[:triggered_by] }
+  token = tokens[triggered_by&.downcase] || tokens.values.first
+  return unless token
+
+  send_discord_message(channel_id, message, token: token)
+rescue StandardError => e
+  LOG.warn "[Brainiac] Failed to send restart notification: #{e.message}"
+end
+
+def any_agents_running?
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    ACTIVE_SESSIONS.any? do |_key, info|
+      Process.kill(0, info[:pid])
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+  end
+end
+
+def execute_restart
+  triggered_by = BRAINIAC_RESTART_MUTEX.synchronize { BRAINIAC_RESTART_STATE[:triggered_by] }
+  LOG.info "[Brainiac] All agents finished, executing restart..."
+  BRAINIAC_RESTART_MUTEX.synchronize { BRAINIAC_RESTART_STATE[:queued] = false }
+
+  send_restart_notification("🔄 Restarting brainiac (triggered by #{triggered_by || "unknown"})...")
+
+  Thread.new do
+    sleep 1
+    source_dir = File.expand_path("../../..", __dir__)
+    receiver_path = File.join(source_dir, "receiver.rb")
+    log_file = File.join(source_dir, "tmp", "brainiac-server.log")
+    FileUtils.mkdir_p(File.dirname(log_file))
+
+    pid = spawn({ "PATH" => ENV.fetch("PATH", nil) }, "ruby", receiver_path,
+                chdir: source_dir, out: [log_file, "a"], err: %i[child out])
+    Process.detach(pid)
+
+    File.write(File.join(BRAINIAC_DIR, "brainiac-server.pid"), pid.to_s)
+
+    sleep 1
+    LOG.info "[Brainiac] Stopping server, new instance started (PID: #{pid}) from #{source_dir}"
+    Sinatra::Application.quit!
+    sleep 0.5
+    exit!
+  end
+end
+
+def start_brainiac_restart_monitor
+  Thread.new do
+    LOG.info "[Brainiac] Restart monitor started, checking every 30s"
+    loop do
+      sleep 30
+      restart_needed = BRAINIAC_RESTART_MUTEX.synchronize { BRAINIAC_RESTART_STATE[:queued] }
+
+      if restart_needed && !any_agents_running?
+        execute_restart
+      elsif restart_needed
+        active_count = ACTIVE_SESSIONS_MUTEX.synchronize { ACTIVE_SESSIONS.size }
+        LOG.info "[Brainiac] Restart queued but #{active_count} agent(s) still running, waiting..."
+      end
+    end
+  end
+end

data/lib/brainiac/routes/api.rb

@@ -0,0 +1,427 @@
+# frozen_string_literal: true
+
+# Admin and data API routes.
+#
+# These are read-only (mostly) endpoints for inspecting system state:
+# projects, agents, users, brain, skills, sessions, logs, etc.
+
+# --- Session Helpers ---
+
+def reap_dead_sessions
+  ACTIVE_SESSIONS.delete_if do |card_key, info|
+    Process.kill(0, info[:pid])
+    false
+  rescue Errno::ESRCH, Errno::EPERM
+    archive_session(card_key, info)
+    true
+  end
+end
+
+def format_active_sessions
+  ACTIVE_SESSIONS.map do |card_key, info|
+    agent_name = resolve_session_agent_name(card_key, info)
+    {
+      card_key: card_key, agent: agent_name, pid: info[:pid],
+      started_at: info[:started_at].iso8601,
+      elapsed_seconds: (Time.now - info[:started_at]).to_i,
+      log_file: info[:log_file], alive: true,
+      children: child_processes_for(info[:pid])
+    }
+  end
+end
+
+def resolve_session_agent_name(card_key, info)
+  return info[:agent_name] if info[:agent_name]
+
+  parts = card_key.split("-")
+  agent_key = if parts[0] == "discord" && parts.size >= 4
+                parts[1]
+              else
+                "Unknown"
+              end
+  fizzy_display_name(agent_key)
+end
+
+def format_recent_sessions
+  RECENT_SESSIONS.map do |s|
+    {
+      card_key: s[:card_key], agent: s[:agent_name] || "Unknown",
+      log_file: s[:log_file], started_at: s[:started_at]&.iso8601,
+      finished_at: s[:finished_at]&.iso8601
+    }
+  end
+end
+
+def kill_child_process(target_pid)
+  Process.kill("TERM", target_pid)
+  Thread.new do
+    sleep 3
+    begin
+      Process.kill(0, target_pid)
+      Process.kill("KILL", target_pid)
+    rescue Errno::ESRCH, Errno::EPERM # rubocop:disable Lint/SuppressedException
+    end
+  end
+  LOG.info "Killed child process #{target_pid} (SIGTERM)"
+  { killed: target_pid }.to_json
+rescue Errno::ESRCH
+  halt 404, { error: "process not found" }.to_json
+rescue Errno::EPERM
+  halt 403, { error: "permission denied" }.to_json
+end
+
+def search_giphy(query, api_key)
+  uri = URI("https://api.giphy.com/v1/gifs/search")
+  uri.query = URI.encode_www_form(api_key: api_key, q: query, limit: 5, rating: "pg-13")
+  response = Net::HTTP.get_response(uri)
+
+  if response.code.to_i == 200
+    results = JSON.parse(response.body)["data"] || []
+    results.map { |g| { url: g.dig("images", "original", "url") || g["url"], title: g["title"] } }
+  else
+    LOG.warn "[GIF] Giphy API returned #{response.code}: #{response.body[0..200]}"
+    nil
+  end
+end
+
+# --- Projects ---
+
+get "/api/projects" do
+  content_type :json
+  reload_projects!
+  { projects: PROJECTS }.to_json
+end
+
+get "/api/projects/:key" do
+  content_type :json
+  reload_projects!
+  project_key = params["key"]
+  if PROJECTS.key?(project_key)
+    { project: PROJECTS[project_key] }.to_json
+  else
+    halt 404, { error: "Project not found" }.to_json
+  end
+end
+
+post "/api/reload" do
+  content_type :json
+  reload_projects!(force: true)
+  reload_agent_registry!(force: true)
+  reload_user_registry!(force: true)
+  reload_github_config!(force: true)
+  reload_deployments_config!(force: true) if defined?(DEPLOYMENTS_CONFIG)
+  ReloadHooks.run_all!
+  { status: "reloaded", projects: PROJECTS.keys, agents: all_agent_names.to_a, registry: AGENT_REGISTRY.keys,
+    users: USER_REGISTRY["users"].size }.to_json
+end
+
+# --- Agents & Roles ---
+
+get "/api/agents" do
+  content_type :json
+  { default: AI_AGENT_NAME, agents: discover_kiro_agents, all_known: all_agent_names.to_a, roster: agent_roster }.to_json
+end
+
+get "/api/roles" do
+  content_type :json
+  roles = []
+  if Dir.exist?(ROLES_DIR)
+    Dir.glob(File.join(ROLES_DIR, "*.md")).each do |f|
+      name = File.basename(f, ".md")
+      agents = AGENT_REGISTRY.select { |_, e| e.is_a?(Hash) && Array(e["role"]).include?(name) }.map { |k, e| e["fizzy_name"] || k.capitalize }
+      roles << { name: name, agents: agents }
+    end
+  end
+  { roles: roles, dir: ROLES_DIR }.to_json
+end
+
+# --- Users ---
+
+get "/api/users" do
+  content_type :json
+  reload_user_registry!
+
+  filter = params["filter"]
+  users = case filter
+          when "humans" then human_users
+          when "agents" then ai_agents
+          else USER_REGISTRY["users"]
+          end
+
+  { users: users, total: USER_REGISTRY["users"].size, schema_version: USER_REGISTRY["schema_version"] }.to_json
+end
+
+get "/api/users/:identifier" do
+  content_type :json
+  reload_user_registry!
+
+  identifier = params["identifier"]
+  user = find_user(identifier)
+
+  if user
+    { user: user }.to_json
+  else
+    halt 404, { error: "User not found", identifier: identifier }.to_json
+  end
+end
+
+# --- Brain ---
+
+get "/api/brain" do
+  content_type :json
+  agent = params["agent"] || AI_AGENT_NAME
+  persona_dir = persona_dir_for(agent)
+  persona_col = persona_collection_for(agent)
+
+  knowledge_files = File.directory?(KNOWLEDGE_DIR) ? Dir.glob(File.join(KNOWLEDGE_DIR, "**", "*.md")).map { |f| f.sub("#{KNOWLEDGE_DIR}/", "") } : []
+  persona_files = File.directory?(persona_dir) ? Dir.glob(File.join(persona_dir, "**", "*.md")).map { |f| f.sub("#{persona_dir}/", "") } : []
+
+  {
+    agent: agent,
+    knowledge: { dir: KNOWLEDGE_DIR, collection: KNOWLEDGE_COLLECTION, files: knowledge_files },
+    persona: { dir: persona_dir, collection: persona_col, files: persona_files }
+  }.to_json
+end
+
+get "/api/brain/search" do
+  content_type :json
+  query = params["q"]
+  halt 400, { error: "Missing query parameter ?q=" }.to_json unless query && !query.empty?
+
+  agent = params["agent"] || AI_AGENT_NAME
+  scope = (params["scope"] || "knowledge").to_sym
+  scope = :knowledge unless %i[knowledge persona].include?(scope)
+  results = query_brain(query, agent_name: agent, scope: scope, max_results: (params["n"] || 5).to_i)
+
+  { agent: agent, scope: scope, query: query, results: results }.to_json
+end
+
+# --- Skills ---
+
+get "/api/skills" do
+  content_type :json
+  skills = build_skill_index
+  { total: skills.size, skills: skills }.to_json
+end
+
+post "/api/skills/curate" do
+  content_type :json
+  result = curate_skills
+  result.to_json
+end
+
+# --- Card Index ---
+
+get "/api/card-index" do
+  content_type :json
+  halt 404, { error: "Card index not enabled (fizzy handler disabled)" }.to_json unless defined?(CARD_INDEX)
+
+  query = params["q"]
+  if query && !query.empty?
+    similar = CARD_INDEX.find_similar_cards(query)
+    { query: query, matches: similar, total_indexed: CARD_INDEX.size }.to_json
+  else
+    { total: CARD_INDEX.size, cards: CARD_INDEX }.to_json
+  end
+end
+
+# --- Dispatch Depth ---
+
+get "/api/dispatch-depth" do
+  content_type :json
+  {
+    max_depth: AGENT_DISPATCH_MAX_DEPTH,
+    window_seconds: AGENT_DISPATCH_WINDOW,
+    cards: AGENT_DISPATCH_DEPTH.transform_values do |v|
+      { count: v[:count], last_human_at: v[:last_human_at]&.iso8601, blocked: v[:count] >= AGENT_DISPATCH_MAX_DEPTH }
+    end
+  }.to_json
+end
+
+# --- Sessions ---
+
+get "/api/status" do
+  content_type :json
+  ACTIVE_SESSIONS_MUTEX.synchronize do
+    reap_dead_sessions
+
+    sessions = format_active_sessions
+    recent = format_recent_sessions
+
+    { sessions: sessions, count: sessions.size, recent: recent, version: BRAINIAC_VERSION,
+      server_root: File.expand_path("../../..", __dir__) }.to_json
+  end
+end
+
+post "/api/sessions/kill/:card_key" do
+  content_type :json
+  card_key = params[:card_key]
+  halt 400, { error: "missing card_key" }.to_json if card_key.to_s.empty?
+
+  killed = kill_session(card_key)
+  halt 404, { error: "session not found" }.to_json unless killed
+
+  LOG.info "Killed agent session #{card_key} via API"
+  { killed: card_key }.to_json
+end
+
+post "/api/sessions/kill-process/:pid" do
+  content_type :json
+  target_pid = params[:pid].to_i
+  halt 400, { error: "invalid pid" }.to_json if target_pid <= 0
+
+  valid = ACTIVE_SESSIONS_MUTEX.synchronize do
+    ACTIVE_SESSIONS.any? do |_, info|
+      child_processes_for(info[:pid]).any? { |c| c[:pid] == target_pid }
+    end
+  end
+  halt 403, { error: "pid is not a child of any active agent session" }.to_json unless valid
+
+  kill_child_process(target_pid)
+end
+
+# --- Logs ---
+
+get "/api/logs" do
+  content_type "text/plain"
+  log_file = params["file"]
+  lines = (params["lines"] || 200).to_i
+
+  halt 400, "Missing ?file= parameter" unless log_file && !log_file.empty?
+  halt 400, "Invalid path" if log_file.include?("..") || !log_file.start_with?("/")
+  halt 404, "File not found" unless File.exist?(log_file)
+
+  allowed = PROJECTS.values.map { |p| File.join(p["repo_path"], "tmp") }
+  allowed << File.join(BRAINIAC_DIR, "tmp")
+  halt 403, "Forbidden" unless allowed.any? { |dir| log_file.start_with?(dir) }
+
+  all_lines = File.readlines(log_file).last(lines)
+  all_lines.join.gsub(/\e\[[\d;]*[a-zA-Z]/, "").gsub(/\e\[\?[\d;]*[a-zA-Z]/, "")
+end
+
+# --- GIF ---
+
+get "/api/gif" do
+  content_type :json
+  query = params[:q].to_s.strip
+  halt 400, { error: "Missing ?q= parameter" }.to_json if query.empty?
+
+  api_key = DISCORD_CONFIG["giphy_api_key"]
+  halt 503, { error: "No giphy_api_key configured in discord.json" }.to_json unless api_key
+
+  gifs = search_giphy(query, api_key)
+  halt 502, { error: "Giphy API error" }.to_json unless gifs
+
+  { query: query, results: gifs }.to_json
+rescue StandardError => e
+  LOG.error "[GIF] Search failed: #{e.message}"
+  halt 500, { error: e.message }.to_json
+end
+
+# --- Cron ---
+
+get "/api/cron/script" do
+  content_type "text/plain"
+  path = params["path"]
+  halt 400, "Missing ?path= parameter" unless path && !path.empty?
+  halt 400, "Invalid path" if path.include?("..")
+
+  valid = CRON_JOBS.values.any? do |j|
+    j[:script] == path || j["script"] == path ||
+      (j[:prompt] || j["prompt"] || "").include?(path)
+  end
+  halt 403, "Not a registered cron script" unless valid
+  halt 404, "File not found" unless File.exist?(path)
+
+  File.read(path)
+end
+
+get "/api/cron" do
+  content_type :json
+  reload_cron_jobs!
+  {
+    enabled: true,
+    jobs: CRON_JOBS,
+    thread_alive: CRON_THREAD[:ref]&.alive? || false
+  }.to_json
+end
+
+post "/api/cron/add" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  result = add_cron_job(
+    id: payload["id"],
+    schedule: payload["schedule"],
+    agent: payload["agent"],
+    project: payload["project"],
+    prompt: payload["prompt"],
+    script: payload["script"],
+    model: payload["model"],
+    effort: payload["effort"],
+    discord_channel_id: payload["discord_channel_id"],
+    forum_title: payload["forum_title"],
+    forum_reply_to_latest: payload["forum_reply_to_latest"] || false,
+    repeat_count: payload["repeat_count"]
+  )
+
+  result.to_json
+end
+
+post "/api/cron/remove" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  result = remove_cron_job(payload["id"])
+  result.to_json
+end
+
+post "/api/cron/toggle" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  result = toggle_cron_job(payload["id"], payload["enabled"])
+  result.to_json
+end
+
+post "/api/cron/update" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  result = update_cron_job(
+    payload["id"],
+    schedule: payload["schedule"],
+    discord_channel_id: payload["discord_channel_id"],
+    forum_title: payload["forum_title"],
+    forum_reply_to_latest: payload["forum_reply_to_latest"]
+  )
+  result.to_json
+end
+
+post "/api/cron/reload" do
+  content_type :json
+  reload_cron_jobs!
+  { status: "reloaded", jobs: CRON_JOBS.size }.to_json
+end
+
+get "/api/cron/logs" do
+  content_type :json
+  job_id = params["id"]
+  halt 400, { error: "Missing ?id= parameter" }.to_json unless job_id && !job_id.empty?
+
+  logs = []
+  PROJECTS.each_value do |proj|
+    tmp_dir = File.join(proj["repo_path"], "tmp")
+    next unless Dir.exist?(tmp_dir)
+
+    Dir.glob(File.join(tmp_dir, "{agent-cron,cron-script}-#{job_id}-*.log")).each do |f|
+      logs << { file: f, size: File.size(f), modified: File.mtime(f).iso8601 }
+    end
+  end
+  logs.sort_by! { |l| l[:modified] }.reverse!
+  logs.first(20).to_json
+end

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/brainiac/zoho_mail_api.rb

@@ -94,7 +94,8 @@ end
 def extract_text_from_mime(mime)
   # Try to find text/plain part
   if mime =~ %r{Content-Type: text/plain[^\r\n]*\r?\n(?:Content-Transfer-Encoding:[^\r\n]*\r?\n)?(?:\r?\n)(.*?)(?:\r?\n------=_Part|\z)}mi
-    return Regexp.last_match(1).gsub("\r\n", "\n").strip
+    return Regexp.last_match(1).gsub("\r\n",
+                                     "\n").strip
   end
 
   # Fallback: extract text/html part and strip tags

data/lib/brainiac.rb

@@ -8,3 +8,10 @@ require_relative "brainiac/prompts"
 require_relative "brainiac/planning"
 require_relative "brainiac/helpers"
 require_relative "brainiac/cron"
+require_relative "brainiac/plugins"
+
+# Namespace for gem-based plugins (brainiac-whatsapp, brainiac-slack, etc.)
+module Brainiac
+  module Plugins
+  end
+end