brainiac 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '04080c41c24921ed739b0d28ad15ce61b8eb5b5c12935d0cb0b1d72c6b0deeab'
-  data.tar.gz: bbb1dceb84ecaba924ada9189e8b63320828c035da4a6ff466ba8b47c4c30708
+  metadata.gz: 123ee48772d662b7c3326b4c90584f3aa85cfeecf0c481f564cb3f79efb4355a
+  data.tar.gz: d81be4471f1665ca426d9c02cc278f04e0fc67a272b6f9c5a82ce7ba05ef00ae
 SHA512:
-  metadata.gz: '0699a2277c78aa2c33e57b6ee4394ac7be8d27bc483a9f3866dd27e644e40fbdea4b85168b3452c6cbbd4fce42da6e282a9609e93541802b2c751f9845c55ea2'
-  data.tar.gz: adcd7eab6269a33b278499e3b873b072f488f7b06b18378507fba456f883b1c525b7dd8d8ce82b13e6464ab5184007e0887dfa9a82a69910f8f8d0164660ff9b
+  metadata.gz: 76b8df7eefa48bb122f7d75ba0730f0b8ac328ad284f45e137297dd650b7f6781bcc6ad14bd1a0a4f1a31a9c24392bd183a4b5b236f086a19bc504257f2cf180
+  data.tar.gz: 7f089331037cc192f3cb284471b497e688d0831a38088f968cf4c5eabd175539a8b8f8e1986ad38739ee7a1efdb1beb81d3777d9f63e99c131fd74d47629dcd8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.14)
+    brainiac (0.0.16)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.14)
+  brainiac (0.0.16)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/bin/brainiac

@@ -120,6 +120,65 @@ rescue StandardError
   []
 end
 
+# Notify the running server to reload configs (triggers agent lifecycle hooks).
+# Silently does nothing if the server isn't running.
+def notify_server_reload
+  config = load_config
+  server_url = config["server_url"] || "http://localhost:4567"
+  uri = URI("#{server_url}/api/reload")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.open_timeout = 2
+  http.read_timeout = 5
+  request = Net::HTTP::Post.new(uri.path)
+  http.request(request)
+rescue StandardError
+  nil
+end
+
+# Run CLI-time plugin hooks for agent lifecycle events.
+# Loads each installed plugin's CLI module and calls the hook method if defined.
+# This runs synchronously and can prompt for interactive input.
+def notify_plugins_agent_created(agent_key, entry)
+  plugins_file = File.join(BRAINIAC_DIR, "plugins.json")
+  return unless File.exist?(plugins_file)
+
+  plugins_config = JSON.parse(File.read(plugins_file))
+  (plugins_config["plugins"] || []).each do |pentry|
+    pname = pentry.is_a?(Hash) ? pentry["name"] : pentry.to_s
+    try_require_metadata(pname, pentry)
+    try_require_plugin_cli(pname, pentry)
+    mod = resolve_plugin_module_for(pname)
+    next unless mod.respond_to?(:on_agent_created)
+
+    mod.on_agent_created(agent_key, entry)
+  rescue StandardError => e
+    puts "  ⚠ Plugin '#{pname}' hook failed: #{e.message}"
+  end
+rescue JSON::ParserError
+  nil
+end
+
+# Run CLI-time plugin hooks for agent removal.
+def notify_plugins_agent_removed(agent_key, display_name)
+  plugins_file = File.join(BRAINIAC_DIR, "plugins.json")
+  return unless File.exist?(plugins_file)
+
+  plugins_config = JSON.parse(File.read(plugins_file))
+  (plugins_config["plugins"] || []).each do |pentry|
+    pname = pentry.is_a?(Hash) ? pentry["name"] : pentry.to_s
+    try_require_metadata(pname, pentry)
+    try_require_plugin_cli(pname, pentry)
+    mod = resolve_plugin_module_for(pname)
+    next unless mod.respond_to?(:on_agent_removed)
+
+    mod.on_agent_removed(agent_key, display_name)
+  rescue StandardError => e
+    puts "  ⚠ Plugin '#{pname}' hook failed: #{e.message}"
+  end
+rescue JSON::ParserError
+  nil
+end
+
 def wait_for_agents_to_finish
   sessions = fetch_active_sessions
   return true if sessions.empty?
@@ -1873,6 +1932,12 @@ when "agent"
       brain_init(name)
     end
 
+    # Let plugins prompt for additional config (e.g. Discord user ID)
+    notify_plugins_agent_created(agent_key, entry)
+
+    # Notify running server to reload and trigger :agent_added hook
+    notify_server_reload
+
   when "remove", "delete", "rm"
     name = ARGV.shift
     unless name
@@ -1894,6 +1959,12 @@ when "agent"
     puts "✓ Removed agent '#{display}' (#{agent_key}) from registry"
     puts "  Note: Persona files at ~/.brainiac/brain/persona/#{agent_key}/ were not deleted."
 
+    # Let plugins clean up their config
+    notify_plugins_agent_removed(agent_key, display)
+
+    # Notify running server to reload and trigger :agent_removed hook
+    notify_server_reload
+
   when nil
     puts <<~HELP
       Usage: brainiac agent <name> <command> [args]

data/lib/brainiac/agents.rb

@@ -50,8 +50,26 @@ AGENT_REGISTRY = load_agent_registry
 def reload_agent_registry!(force: false)
   return unless file_changed?(AGENT_REGISTRY_FILE, force: force)
 
+  old_keys = AGENT_REGISTRY.keys.to_set
   AGENT_REGISTRY.replace(load_agent_registry)
+  new_keys = AGENT_REGISTRY.keys.to_set
   LOG.info "Reloaded agent registry: #{AGENT_REGISTRY.keys.join(", ")}"
+
+  # Emit lifecycle hooks for added/removed agents
+  added = new_keys - old_keys
+  removed = old_keys - new_keys
+
+  added.each do |key|
+    entry = AGENT_REGISTRY[key]
+    display_name = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    LOG.info "Agent added: #{display_name} (#{key})"
+    Brainiac.emit(:agent_added, agent_key: key, display_name: display_name, entry: entry)
+  end
+
+  removed.each do |key|
+    LOG.info "Agent removed: #{key}"
+    Brainiac.emit(:agent_removed, agent_key: key)
+  end
 end
 
 # Get the env hash for an agent. Returns {} if none configured.

data/lib/brainiac/helpers.rb

@@ -402,11 +402,11 @@ end
 # Check if intent detection says to skip dispatching the agent.
 # Returns true if the message should be skipped, false otherwise.
 # Only runs if a raw message is provided, an agent is named, and intent is enabled.
-def intent_skip?(message, agent_name:, source: nil, channel: nil)
+def intent_skip?(message, agent_name:, source: nil, channel: nil, context: nil)
   return false unless message && agent_name && intent_config["enabled"]
 
   intent_channel = channel || source&.to_s || "conversation"
-  unless check_intent(message, agent_name: agent_name, channel: intent_channel)
+  unless check_intent(message, agent_name: agent_name, channel: intent_channel, context: context)
     LOG.info "[Intent] Skipping dispatch for #{agent_name} — message classified as not requiring response"
     return true
   end
@@ -416,9 +416,9 @@ end
 
 def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil, effort: nil, agent_name: nil, card_number: nil, comment_id: nil,
               source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
-              message: nil, channel: nil)
+              message: nil, channel: nil, context: nil)
   # Intent gate: if a raw message is provided, check whether the agent should respond.
-  return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel)
+  return nil if intent_skip?(message, agent_name: agent_name, source: source, channel: channel, context: context)
 
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]

data/lib/brainiac/hooks.rb

@@ -9,6 +9,8 @@
 #
 # Events:
 #   :agent_completed    — After an agent session finishes (success or failure)
+#   :agent_added        — When a new agent appears in the registry (after reload)
+#   :agent_removed      — When an agent is removed from the registry (after reload)
 #   :pr_merged          — After a GitHub PR is merged
 #   :pr_opened          — After a GitHub PR is opened
 #   :pr_reviewed        — After a PR review is submitted

data/lib/brainiac/intent.rb

@@ -38,15 +38,27 @@ INTENT_CONFIG_DEFAULTS = {
 INTENT_PROMPT_TEMPLATE = <<~PROMPT
   You are a message router for a {{CHANNEL}}. An AI agent named {{AGENT_NAME}} is participating in this conversation. Your job: determine if the latest message requires {{AGENT_NAME}} to take action or respond.
 
+  {{AGENT_ROSTER}}
+
   Rules:
-  - If the message is giving {{AGENT_NAME}} instructions, asking {{AGENT_NAME}} a question, or continuing a conversation WITH {{AGENT_NAME}} → yes
+  - If the message addresses {{AGENT_NAME}} by name, gives {{AGENT_NAME}} instructions, or asks {{AGENT_NAME}} a question → yes
+  - If the message continues a conversation directed at {{AGENT_NAME}} (e.g. {{AGENT_NAME}} was the last to respond and the human follows up) → yes
+  - If the message starts with or addresses a DIFFERENT person/agent (not {{AGENT_NAME}}) → no
+  - If the message contains another agent's name (e.g. "Effie, ...", "Another one Effie", "Hey Galen") and does NOT contain "{{AGENT_NAME}}" → no
   - If the message is humans talking to each other and {{AGENT_NAME}} is not being addressed → no
-  - If the message is a simple acknowledgment (like "thanks", "ok", "got it") directed at {{AGENT_NAME}}'s previous work → no
-  - If the message is asking a question to another person or agent → no
+  - If the message is a simple acknowledgment ("thanks", "ok", "got it") directed at {{AGENT_NAME}}'s previous work → no
+  - If the message is asking a question to another person or agent (not {{AGENT_NAME}}) → no
+  - If the message is responding to or commenting on what someone OTHER than {{AGENT_NAME}} just said → no
+  - If the conversation context shows a DIFFERENT agent was the last to respond, and the human's follow-up does not mention {{AGENT_NAME}} by name → no
   - If uncertain, lean toward yes (better to respond unnecessarily than miss a request)
 
+  Critical: "addresses someone else" means someone whose name is NOT {{AGENT_NAME}}. If the message says "{{AGENT_NAME}}, ..." that IS addressed to {{AGENT_NAME}} → yes.
+
   Respond with ONLY "yes" or "no" — nothing else.
 
+  Context:
+  {{CONTEXT}}
+
   Latest message:
   {{MESSAGE}}
 PROMPT
@@ -67,33 +79,114 @@ PENDING_WORK_PROMPT_TEMPLATE = <<~PROMPT
   {{MESSAGE}}
 PROMPT
 
+# Custom error for missing Ollama models — provides actionable install instructions.
+class OllamaModelNotFoundError < RuntimeError
+  attr_reader :model_name, :endpoint
+
+  def initialize(model_name, endpoint)
+    @model_name = model_name
+    @endpoint = endpoint
+    super(<<~MSG.strip)
+      Ollama model '#{model_name}' is not installed.
+
+      To install it, run:
+        ollama pull #{model_name}
+
+      Or change the model in ~/.brainiac/brainiac.json → intent.model
+
+      Available models can be listed with:
+        ollama list
+    MSG
+  end
+end
+
 # Load intent config from brainiac.json, merging with defaults.
 def intent_config
   raw = BRAINIAC_CONFIG["intent"] || {}
   INTENT_CONFIG_DEFAULTS.merge(raw)
 end
 
+# Validate that the configured intent model is available in Ollama.
+# Called at server startup — aborts with a helpful error if the model is missing.
+#
+# @param config [Hash] Intent configuration
+# @raise [OllamaModelNotFoundError] if the model isn't installed
+def validate_intent_model!(config)
+  base_uri = URI(config["endpoint"])
+  show_uri = URI("#{base_uri.scheme}://#{base_uri.host}:#{base_uri.port}/api/show")
+
+  http = Net::HTTP.new(show_uri.host, show_uri.port)
+  http.open_timeout = 5
+  http.read_timeout = 5
+
+  request = Net::HTTP::Post.new(show_uri.path, "Content-Type" => "application/json")
+  request.body = JSON.generate({ model: config["model"] })
+
+  response = http.request(request)
+
+  if response.code == "404" || (!response.is_a?(Net::HTTPSuccess) && response.body&.include?("not found"))
+    raise OllamaModelNotFoundError.new(config["model"], config["endpoint"])
+  end
+
+  true
+rescue Errno::ECONNREFUSED
+  raise "Ollama is not running at #{config["endpoint"]}. Start it with: ollama serve"
+rescue Net::OpenTimeout, Net::ReadTimeout
+  LOG.warn "[Intent] Could not validate model (Ollama timed out) — will check at first use"
+  true
+end
+
 # Check whether a message requires an agent to respond.
 #
 # @param message [String] The message text to classify
 # @param agent_name [String] The agent being addressed
 # @param channel [String] Context description (e.g., "Discord thread", "Fizzy card comment")
+# @param context [String, nil] Recent conversation history for flow detection
 # @return [Boolean] true if the agent should respond, false if it can be skipped
-def check_intent(message, agent_name:, channel: "conversation")
+def check_intent(message, agent_name:, channel: "conversation", context: nil)
   config = intent_config
   return true unless config["enabled"]
   return true if message.nil? || message.strip.empty?
 
+  # Deterministic pre-check: if the message explicitly names another agent
+  # and does NOT name this agent, skip without consulting the LLM.
+  # This handles the common case of "Effie, tell me another" when checking Galen.
+  if intent_names_other_agent?(message, agent_name)
+    LOG.info "[Intent] Deterministic skip for #{agent_name} — message addresses another agent"
+    return false
+  end
+
+  context_block = if context && !context.strip.empty?
+                    # Keep only last 5 messages for the small local model — enough to determine
+                    # conversational flow without overwhelming the context window.
+                    recent = context.strip.lines.last(5).join
+                    "Recent conversation (most recent last):\n#{recent}\n\n"
+                  else
+                    ""
+                  end
+
+  # Build agent roster for the prompt so the model knows which names are agents
+  roster_block = build_intent_agent_roster(agent_name)
+
   prompt = INTENT_PROMPT_TEMPLATE
            .gsub("{{AGENT_NAME}}", agent_name)
            .gsub("{{CHANNEL}}", channel)
+           .gsub("{{AGENT_ROSTER}}", roster_block)
+           .gsub("{{CONTEXT}}", context_block)
            .gsub("{{MESSAGE}}", message.strip)
 
   LOG.info "[Intent] Checking intent for #{agent_name} (#{channel}): #{message.strip.slice(0, 80)}..."
+  LOG.debug "[Intent] Full prompt:\n#{prompt}" if LOG.debug?
   response = query_local_llm(prompt, config)
   result = positive_intent?(response)
   LOG.info "[Intent] Result: #{result ? "RESPOND" : "SKIP"} (model: #{config["model"]})"
   result
+rescue OllamaModelNotFoundError => e
+  LOG.error "[Intent] #{e.message}"
+  LOG.error "[Intent] Disabling intent classification until model is installed."
+  BRAINIAC_CONFIG["intent"] ||= {}
+  BRAINIAC_CONFIG["intent"]["enabled"] = false
+  true
 rescue StandardError => e
   LOG.warn "[Intent] Classification failed (fail-open): #{e.message}"
   true
@@ -121,12 +214,17 @@ def query_local_llm(prompt, config)
   request.body = JSON.generate(payload)
 
   response = http.request(request)
-  raise "Ollama returned #{response.code}: #{response.body&.slice(0, 200)}" unless response.is_a?(Net::HTTPSuccess)
+
+  unless response.is_a?(Net::HTTPSuccess)
+    raise OllamaModelNotFoundError.new(config["model"], config["endpoint"]) if response.code == "404" && response.body&.include?("not found")
+
+    raise "Ollama returned #{response.code}: #{response.body&.slice(0, 200)}"
+  end
 
   body = JSON.parse(response.body)
   body["response"] || ""
 rescue Errno::ECONNREFUSED
-  raise "Ollama not running at #{config["endpoint"]}"
+  raise "Ollama not running at #{config["endpoint"]}. Start it with: ollama serve"
 rescue Net::OpenTimeout, Net::ReadTimeout
   raise "Ollama timed out after #{config["timeout"]}s"
 end
@@ -177,3 +275,102 @@ def pending_work_detected?(response)
   cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
   cleaned == "yes"
 end
+
+# Deterministic check: does the message explicitly name another known agent
+# without mentioning this agent? If so, the message is clearly directed elsewhere.
+#
+# Only triggers when:
+# 1. The message contains another agent's display name (case-insensitive word boundary match)
+# 2. The message does NOT contain this agent's name
+#
+# This avoids the LLM entirely for obvious cases like "Effie, tell me another"
+# when evaluating whether Galen should respond.
+#
+# Determines if the message is DIRECTLY ADDRESSED to another agent (not just mentioning them).
+# Only triggers on vocative patterns — where the name is used to call someone, not refer to them.
+#
+# Patterns that indicate direct address (skip this agent):
+#   - "Effie, tell me a joke" (name + comma at start)
+#   - "hey Effie one more" (greeting + name)
+#   - "Another one Effie" (name at end, imperative)
+#   - "Effie tell me more" (name at start, imperative — no comma but first word)
+#
+# Patterns that are merely MENTIONING (do NOT skip):
+#   - "What do you think about Effie's answer?" (talking about Effie)
+#   - "Was Effie nice to you?" (asking about Effie)
+#   - "I liked what Effie said" (referencing Effie)
+#
+# @param message [String] The message text
+# @param agent_name [String] The agent being evaluated
+# @return [Boolean] true if another agent is directly addressed and this one isn't
+def intent_names_other_agent?(message, agent_name)
+  return false unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  msg_lower = message.downcase.strip
+  agent_lower = agent_name.downcase
+
+  # If this agent IS named in the message, never deterministic skip
+  return false if msg_lower.match?(/\b#{Regexp.escape(agent_lower)}\b/)
+
+  # Check if any OTHER agent is directly addressed (not merely mentioned)
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    other_lower = display.downcase
+    next if other_lower == agent_lower
+    next unless msg_lower.match?(/\b#{Regexp.escape(other_lower)}\b/)
+
+    # Agent name is present — now determine if it's direct address or mere mention
+    return true if directly_addressed_to?(msg_lower, other_lower)
+  end
+
+  false
+end
+
+# Heuristics for detecting direct address (vocative use of a name).
+# Returns true when the name is used to CALL someone, not talk ABOUT them.
+#
+# @param msg [String] Lowercased, stripped message
+# @param name [String] Lowercased agent name to check
+# @return [Boolean]
+def directly_addressed_to?(msg, name)
+  escaped = Regexp.escape(name)
+
+  # Pattern 1: Name at the very start (with or without comma/colon)
+  # "Effie, tell me a joke" / "Effie tell me more" / "Effie: do the thing"
+  return true if msg.match?(/\A#{escaped}[\s,:!]/i)
+
+  # Pattern 2: Name at the very end (imperative directed at them)
+  # "Another one Effie" / "one more Effie"
+  # BUT NOT when preceded by a preposition — "agree with Effie?" is about Effie, not to her
+  if msg.match?(/\s#{escaped}\s*[.!?]?\z/i)
+    prepositions = /\b(?:with|about|from|to|for|of|by|like|than|as|at|on|against|toward|towards)\s+#{escaped}\s*[.!?]?\z/i
+    return true unless msg.match?(prepositions)
+  end
+
+  # Pattern 3: Greeting/vocative prefix + name
+  # "hey Effie" / "yo Effie" / "ok Effie" / "thanks Effie"
+  return true if msg.match?(/\b(?:hey|hi|yo|ok|okay|thanks|thank you|please)\s+#{escaped}\b/i)
+
+  # Pattern 4: Name followed by comma mid-sentence (vocative comma)
+  # "so Effie, what do you think?"
+  return true if msg.match?(/\b#{escaped}\s*,/i)
+
+  false
+end
+
+# Build a compact agent roster string for the intent prompt.
+# Helps the LLM identify which names in the conversation are agents.
+#
+# @param agent_name [String] The current agent (highlighted)
+# @return [String] Formatted roster for prompt injection
+def build_intent_agent_roster(agent_name)
+  return "" unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  names = AGENT_REGISTRY.map do |key, entry|
+    entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+  end.uniq
+
+  return "" if names.size <= 1
+
+  "Known agents in this system: #{names.join(", ")}. You are routing for #{agent_name}."
+end

data/lib/brainiac/version.rb

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

data/receiver.rb

@@ -101,6 +101,15 @@ end
 LOG.info "[Brainiac] Starting v#{BRAINIAC_VERSION} on port #{settings.port} (#{settings.environment})"
 if intent_config["enabled"]
   LOG.info "[Intent] Enabled — model: #{intent_config["model"]}, endpoint: #{intent_config["endpoint"]}"
+  begin
+    validate_intent_model!(intent_config)
+    LOG.info "[Intent] Model '#{intent_config["model"]}' verified ✓"
+  rescue OllamaModelNotFoundError => e
+    LOG.fatal "[Intent] FATAL: #{e.message}"
+    abort "\n#{e.message}\n"
+  rescue RuntimeError => e
+    LOG.warn "[Intent] Startup validation skipped: #{e.message}"
+  end
 else
   LOG.info "[Intent] Disabled (enable in brainiac.json → intent.enabled: true)"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - Andy Davis