brainiac 0.0.6 → 0.0.7

data/receiver.rb

@@ -19,10 +19,40 @@ require_relative "lib/brainiac/prompts"
 require_relative "lib/brainiac/planning"
 require_relative "lib/brainiac/helpers"
 require_relative "lib/brainiac/cron"
-require_relative "lib/brainiac/handlers/fizzy"
-require_relative "lib/brainiac/handlers/github"
-require_relative "lib/brainiac/card_index"
-require_relative "lib/brainiac/deployments"
+require_relative "lib/brainiac/restart"
+require_relative "lib/brainiac/plugins"
+require_relative "lib/brainiac/handlers/shared/git"
+require_relative "lib/brainiac/handlers/shared/inline_tags"
+
+# Namespace for gem-based plugins (brainiac-whatsapp, brainiac-slack, etc.)
+module Brainiac
+  module Plugins
+  end
+end
+
+# --- Conditional handler loading (based on ~/.brainiac/brainiac.json) ---
+
+if handler_enabled?("fizzy")
+  require_relative "lib/brainiac/handlers/fizzy"
+  require_relative "lib/brainiac/handlers/fizzy/card_index"
+  require_relative "lib/brainiac/handlers/fizzy/deployments"
+  LOG.info "[Handlers] Fizzy handler enabled"
+end
+
+if handler_enabled?("github")
+  require_relative "lib/brainiac/handlers/github"
+  LOG.info "[Handlers] GitHub handler enabled"
+end
+
+if DISCORD_ENABLED && handler_enabled?("discord")
+  require_relative "lib/brainiac/handlers/discord"
+  LOG.info "[Handlers] Discord handler enabled"
+end
+
+if DISCORD_ENABLED && handler_enabled?("zoho")
+  require_relative "lib/brainiac/handlers/zoho"
+  LOG.info "[Handlers] Zoho handler enabled"
+end
 
 # Reload hook registry — custom handlers register callbacks here
 module ReloadHooks
@@ -45,15 +75,18 @@ end
 CUSTOM_HANDLERS_DIR = File.join(BRAINIAC_DIR, "handlers")
 if Dir.exist?(CUSTOM_HANDLERS_DIR)
   Dir.glob(File.join(CUSTOM_HANDLERS_DIR, "*.rb")).each do |handler|
-    LOG.info "[Handlers] Loading custom handler: #{File.basename(handler)}"
+    handler_name = File.basename(handler, ".rb")
+    unless handler_enabled?(handler_name)
+      LOG.info "[Handlers] Skipping custom handler (disabled): #{handler_name}"
+      next
+    end
+    LOG.info "[Handlers] Loading custom handler: #{handler_name}"
     require handler
   end
 end
 
-if DISCORD_ENABLED
-  require_relative "lib/brainiac/handlers/discord"
-  require_relative "lib/brainiac/handlers/zoho"
-end
+# --- Load gem-based plugins (brainiac-*) ---
+load_plugins!(self)
 
 # --- Sinatra config ---
 set :host_authorization, { permit_all: true }
@@ -398,247 +431,7 @@ if DISCORD_ENABLED
 end
 
 # --- Admin API routes ---
-
-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)
-  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
-
-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
-
-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 API routes ---
-
-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
-
-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
-
-get "/api/card-index" do
-  content_type :json
-  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
-
-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
-
-get "/api/status" do
-  content_type :json
-  ACTIVE_SESSIONS_MUTEX.synchronize do
-    # Clean up stale sessions first
-    ACTIVE_SESSIONS.delete_if do |card_key, info|
-      Process.kill(0, info[:pid])
-      false # Keep alive sessions
-    rescue Errno::ESRCH, Errno::EPERM
-      archive_session(card_key, info)
-      true # Remove dead sessions
-    end
-
-    sessions = ACTIVE_SESSIONS.map do |card_key, info|
-      # Use stored agent_name if available, otherwise try to extract from card_key
-      agent_name = if info[:agent_name]
-                     info[:agent_name]
-                   else
-                     # Fallback: extract from card_key for backwards compatibility
-                     # Formats: "discord-AGENT-CHANNEL-MESSAGE" or "card-ID"
-                     parts = card_key.split("-")
-                     agent_key = if parts[0] == "discord" && parts.size >= 4
-                                   parts[1] # Second part is agent name
-                                 else
-                                   "Unknown"
-                                 end
-                     fizzy_display_name(agent_key)
-                   end
-
-      {
-        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
-
-    recent = 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
-
-    { sessions: sessions, count: sessions.size, recent: recent, version: BRAINIAC_VERSION }.to_json
-  end
-end
-
-# Kill an entire agent session (parent process + all children)
-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
-
-# Kill a specific child process of an active agent session
-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
-
-  # Verify the target PID is actually a descendant of an active session
-  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
-
-  begin
-    Process.kill("TERM", target_pid)
-    # Give it a moment, then force kill if still alive
-    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
-end
+require_relative "lib/brainiac/routes/api"
 
 # --- Dashboard ---
 
@@ -660,25 +453,6 @@ get "/dashboard" do
   erb :dashboard, layout: false
 end
 
-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)
-
-  # Only allow reading log files from known project tmp dirs or brainiac tmp
-  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) }
-
-  # Read last N lines and strip ANSI escape codes
-  all_lines = File.readlines(log_file).last(lines)
-  all_lines.join.gsub(/\e\[[\d;]*[a-zA-Z]/, "").gsub(/\e\[\?[\d;]*[a-zA-Z]/, "")
-end
-
 # --- Discord API + startup ---
 
 if DISCORD_ENABLED
@@ -737,197 +511,62 @@ else
   end
 end
 
-# --- Cron API + startup ---
+# --- Deployment environment tracking (requires fizzy handler) ---
 
-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?("..")
-
-  # Only allow reading scripts that are actually referenced by a cron job
-  reload_cron_jobs!
-  valid = CRON_JOBS.values.any? do |j|
-    j[:script] == path || j["script"] == path ||
-      (j[:prompt] || j["prompt"] || "").include?(path)
+if defined?(DEPLOYMENTS_CONFIG)
+  get "/api/deployments" do
+    content_type :json
+    reload_deployments_config!
+    reload_deployment_state!
+    { deployments: deployment_status }.to_json
   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)
+  post "/api/deployments/:env" do
+    content_type :json
+    env_key = params["env"]
+    request.body.rewind
+    payload = JSON.parse(request.body.read)
 
-    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 }
+    result = deploy_to_environment(env_key, worktree_path: payload["worktree"], deployed_by: payload["deployed_by"])
+    if result[:error]
+      halt 404, result.to_json
+    else
+      { status: "deployed", env: env_key, deployment: result }.to_json
     end
+  rescue JSON::ParserError
+    halt 400, { error: "Invalid JSON" }.to_json
   end
-  logs.sort_by! { |l| l[:modified] }.reverse!
-  logs.first(20).to_json
-end
-
-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
 
-  begin
-    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"] || []
-      gifs = results.map { |g| { url: g.dig("images", "original", "url") || g["url"], title: g["title"] } }
-      { query: query, results: gifs }.to_json
+  delete "/api/deployments/:env" do
+    content_type :json
+    env_key = params["env"]
+    state = load_deployment_state
+    if state.key?(env_key)
+      state[env_key] = { "status" => "available", "cleared_at" => Time.now.iso8601, "last_card" => state[env_key]["card_number"] }
+      save_deployment_state(state)
+      DEPLOYMENT_STATE.replace(state)
+      LOG.info "[Deploy] Manually cleared #{env_key}"
+      { status: "cleared", env: env_key }.to_json
     else
-      LOG.warn "[GIF] Giphy API returned #{response.code}: #{response.body[0..200]}"
-      halt 502, { error: "Giphy API error: #{response.code}" }.to_json
+      halt 404, { error: "Unknown environment: #{env_key}" }.to_json
     end
-  rescue StandardError => e
-    LOG.error "[GIF] Search failed: #{e.message}"
-    halt 500, { error: e.message }.to_json
-  end
-end
-
-# --- Deployment environment tracking ---
-
-get "/api/deployments" do
-  content_type :json
-  reload_deployments_config!
-  reload_deployment_state!
-  { deployments: deployment_status }.to_json
-end
-
-post "/api/deployments/:env" do
-  content_type :json
-  env_key = params["env"]
-  request.body.rewind
-  payload = JSON.parse(request.body.read)
-
-  result = deploy_to_environment(env_key, worktree_path: payload["worktree"], deployed_by: payload["deployed_by"])
-  if result[:error]
-    halt 404, result.to_json
-  else
-    { status: "deployed", env: env_key, deployment: result }.to_json
-  end
-rescue JSON::ParserError
-  halt 400, { error: "Invalid JSON" }.to_json
-end
-
-delete "/api/deployments/:env" do
-  content_type :json
-  env_key = params["env"]
-  state = load_deployment_state
-  if state.key?(env_key)
-    state[env_key] = { "status" => "available", "cleared_at" => Time.now.iso8601, "last_card" => state[env_key]["card_number"] }
-    save_deployment_state(state)
-    DEPLOYMENT_STATE.replace(state)
-    LOG.info "[Deploy] Manually cleared #{env_key}"
-    { status: "cleared", env: env_key }.to_json
-  else
-    halt 404, { error: "Unknown environment: #{env_key}" }.to_json
   end
-end
 
-post "/api/deployments/:env/deploying" do
-  content_type :json
-  env_key = params["env"]
-  config = DEPLOYMENTS_CONFIG["environments"] || {}
-  halt 404, { error: "Unknown environment: #{env_key}" }.to_json unless config.key?(env_key)
-  request.body.rewind
-  payload = begin
-    JSON.parse(request.body.read)
-  rescue StandardError
-    {}
+  post "/api/deployments/:env/deploying" do
+    content_type :json
+    env_key = params["env"]
+    config = DEPLOYMENTS_CONFIG["environments"] || {}
+    halt 404, { error: "Unknown environment: #{env_key}" }.to_json unless config.key?(env_key)
+    request.body.rewind
+    payload = begin
+      JSON.parse(request.body.read)
+    rescue StandardError
+      {}
+    end
+    mark_deploying(env_key, worktree_path: payload["worktree"] || "")
+    LOG.info "[Deploy] #{env_key} marked deploying via API"
+    { status: "deploying", env: env_key }.to_json
   end
-  mark_deploying(env_key, worktree_path: payload["worktree"] || "")
-  LOG.info "[Deploy] #{env_key} marked deploying via API"
-  { status: "deploying", env: env_key }.to_json
 end
 
 LOG.info "[Cron] Starting cron thread..."
@@ -944,8 +583,10 @@ CURATOR_THREAD = Thread.new do
   end
 end
 
-LOG.info "[CardIndex] Starting background backfill..."
-CARD_INDEX.backfill
+if defined?(CARD_INDEX)
+  LOG.info "[CardIndex] Starting background backfill..."
+  CARD_INDEX.backfill
+end
 
 LOG.info "[Monitor] Starting daemon..."
 daemon_path = File.join(__dir__, "monitor", "daemon.rb")

data/templates/brainiac.json.example

@@ -0,0 +1,9 @@
+{
+  "default_agent": "Galen",
+  "handlers": {
+    "fizzy": true,
+    "github": true,
+    "discord": true,
+    "zoho": false
+  }
+}

data/templates/cli-providers/kiro.json.example

@@ -1,6 +1,6 @@
 {
   "binary": "kiro-cli",
-  "default_args": "chat --trust-all-tools --no-interactive --trust-tools execute_bash,fs_write,fs_read,code,grep,glob,web_search,web_fetch,use_subagent,use_aws",
+  "default_args": "chat --trust-all-tools --no-interactive",
   "agent_flag": "--agent",
   "model_flag": "--model",
   "effort_flag": "--effort",
@@ -9,7 +9,13 @@
   "models": {
     "opus": "claude-opus-4.6",
     "sonnet": "claude-sonnet-4.6",
-    "haiku": "claude-haiku-4.5"
+    "haiku": "claude-haiku-4.5",
+    "deepseek": "deepseek-3.2",
+    "minimax": "minimax-m2.5",
+    "minimax25": "minimax-m2.5",
+    "minimax21": "minimax-m2.1",
+    "qwen": "qwen3-coder-next",
+    "auto": "auto"
   },
   "efforts": ["low", "medium", "high", "xhigh", "max"]
 }

data/templates/plugins.json.example

@@ -0,0 +1,3 @@
+{
+  "plugins": []
+}