brainiac 0.0.18 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a5e88ff667021341d3ff4bd4da63212b3918b8c210d276c3c9d0f00ff97e121
-  data.tar.gz: ba02b2ab6f6e0e519ef00887da6f53fb6be2dd234fb8db30bc5bc7c9896433b5
+  metadata.gz: 619fac25bcbc560564a318e78421b8c826811abe7ba92e74de0b3b7104d8a712
+  data.tar.gz: acc359990201eaabfb5d755c17102867bce0a5a1bc68407c09ef3c4fcca94e7c
 SHA512:
-  metadata.gz: 013f765fe110ad69fa3522ba45d46f3200f8f34bad4da62cc3df78b751246d52056b226005ecfce2cda99fbfb77e82230c1e6b679a5525d49b471770776c3249
-  data.tar.gz: b206d36e38e5fd284a8e276109e1a5656986f954f87e393cefa7ef77a0b1f0226b96fc50c80027e00ac66e60dc64107560fbe64d77d3a84198adb673cd1ca50c
+  metadata.gz: e44c64a94143b7eb8ff47312d8b889baf91d654a5341c2a5436329693e6ed700432d6f37428c4e44cddc0369d1c1453a6df69929ac577017b6fe1900c9fa7fe5
+  data.tar.gz: 64500e610c6cc4393a640d069c442c1bff5913ca36e61cc0d0f1323891419760aef1b2e9f7717a66326d731d4b2df139e17aa47ff90b5b0f05764b3402176a71

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.18)
+    brainiac (0.0.20)
       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.18)
+  brainiac (0.0.20)
   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

@@ -2392,7 +2392,10 @@ when "update", "upgrade"
       puts "✓ #{gem_name} is already at the latest version (#{current_version})"
     end
   else
-    # Update brainiac itself: brainiac update
+    # Update brainiac itself + all installed plugins: brainiac update
+    any_updated = false
+
+    # --- Update brainiac core ---
     current_version = BRAINIAC_VERSION
 
     puts "Updating brainiac gem..."
@@ -2404,22 +2407,73 @@ when "update", "upgrade"
       exit 1
     end
 
-    # Parse installed version from gem install output
     new_version = output[/Successfully installed brainiac-(\S+)/, 1]
 
     if new_version
       puts "✓ Updated brainiac: #{current_version} → #{new_version}"
-
-      if find_server_pid
-        puts "  Restarting server to apply..."
-        wait_for_agents_to_finish
-        stop_server
-        sleep 2
-        start_server(daemon: true)
-      end
+      any_updated = true
     else
       puts "✓ brainiac is already at the latest version (#{current_version})"
     end
+
+    # --- Update all installed plugins ---
+    plugins_file = File.join(BRAINIAC_DIR, "plugins.json")
+    plugins_config = if File.exist?(plugins_file)
+                       JSON.parse(File.read(plugins_file))
+                     else
+                       { "plugins" => [] }
+                     end
+
+    plugins = (plugins_config["plugins"] || []).reject do |p|
+      entry = p.is_a?(Hash) ? p : { "name" => p.to_s }
+      # Skip local-path plugins — they're updated via git
+      entry["path"]
+    end
+
+    if plugins.any?
+      puts ""
+      puts "Checking #{plugins.size} installed plugin(s) for updates..."
+      puts ""
+
+      plugins.each do |p|
+        entry = p.is_a?(Hash) ? p : { "name" => p.to_s }
+        plugin_name = entry["name"]
+        gem_name = entry["gem"] || "brainiac-#{plugin_name}"
+
+        plugin_current = begin
+          spec = Gem::Specification.find_by_name(gem_name)
+          spec.version.to_s
+        rescue Gem::MissingSpecError
+          nil
+        end
+
+        plugin_output, plugin_status = Open3.capture2e("gem install #{gem_name}")
+
+        unless plugin_status.success?
+          puts "  ✗ #{gem_name}: failed to update"
+          next
+        end
+
+        plugin_new = plugin_output[/Successfully installed #{Regexp.escape(gem_name)}-(\S+)/, 1]
+
+        if plugin_new
+          puts "  ✓ #{gem_name}: #{plugin_current || "unknown"} → #{plugin_new}"
+          any_updated = true
+        else
+          puts "  ✓ #{gem_name}: already at latest (#{plugin_current})"
+        end
+      end
+    end
+
+    # --- Restart server if anything was updated ---
+    if any_updated && find_server_pid
+      puts ""
+      puts "Restarting server to apply updates..."
+      wait_for_agents_to_finish
+      stop_server
+      sleep 2
+      start_server(daemon: true)
+    end
   end
 
 when "install"
@@ -3150,8 +3204,8 @@ when "help", "--help", "-h", nil
         brainiac projects default <key> Set the default project
         brainiac show <key>             Show project configuration
         brainiac plugin new <name>      Generate a new plugin gem skeleton
-        brainiac update                  Update brainiac to the latest version
-        brainiac update <plugin>        Update an installed plugin to the latest version
+        brainiac update                  Update brainiac and all installed plugins
+        brainiac update <plugin>        Update a specific installed plugin
         brainiac install <plugin>       Install a Brainiac plugin (gem-based handler)
         brainiac uninstall <plugin>     Remove an installed plugin
         brainiac plugins                List installed plugins
@@ -3172,7 +3226,7 @@ when "help", "--help", "-h", nil
         plugin new <name>                Generate a new plugin gem skeleton
         install <name>                   Install a plugin (gem install brainiac-<name>)
         uninstall <name>                 Remove a plugin
-        update [name]                    Update brainiac or a specific plugin
+        update [name]                    Update brainiac + all plugins, or a specific plugin
         plugins                          List installed plugins
 
       Card Map Commands:

data/lib/brainiac/intent.rb

@@ -14,8 +14,8 @@
 #
 #   "intent": {
 #     "enabled": true,
-#     "endpoint": "http://localhost:11434/api/generate",
-#     "model": "gemma3:4b",
+#     "endpoint": "http://localhost:11434/api/chat",
+#     "model": "qwen3:1.7b",
 #     "timeout": 10,
 #     "temperature": 0.1
 #   }
@@ -29,40 +29,24 @@
 
 INTENT_CONFIG_DEFAULTS = {
   "enabled" => false,
-  "endpoint" => "http://localhost:11434/api/generate",
-  "model" => "gemma3:4b",
+  "endpoint" => "http://localhost:11434/api/chat",
+  "model" => "qwen2.5:3b",
   "timeout" => 10,
-  "temperature" => 0.1
+  "temperature" => 0.0
 }.freeze
 
 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.
+  Agents in this chat: {{AGENT_ROSTER}}
+  {{LAST_RESPONDER}}
 
-  {{AGENT_ROSTER}}
+  Human's message: "{{MESSAGE}}"
 
-  Rules:
-  - 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 ("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}}
+  Is this message directed at {{AGENT_NAME}}? Answer yes or no.
 PROMPT
 
+# Words/phrases that indicate pure acknowledgment — no action needed from the agent.
+ACKNOWLEDGMENT_PATTERN = /\A\s*(thanks|thank you|thx|ty|ok|okay|k|got it|sounds good|cool|nice|👍|🙏|✅)\s*[.!]?\s*\z/i
+
 PENDING_WORK_PROMPT_TEMPLATE = <<~PROMPT
   You are analyzing a message posted by an AI agent named {{AGENT_NAME}}. Your job: determine if this message indicates the agent intends to do more work that hasn't been completed yet.
 
@@ -138,6 +122,13 @@ end
 
 # Check whether a message requires an agent to respond.
 #
+# Uses a layered approach:
+# 1. Deterministic pre-checks (fast, no LLM):
+#    - If message names another agent → skip
+#    - If this agent was last to speak AND message isn't pure acknowledgment → respond
+#    - If a different agent was last to speak AND message doesn't name this agent → skip
+# 2. LLM fallback (only for ambiguous cases — no agent spoke, or mixed signals)
+#
 # @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")
@@ -156,61 +147,97 @@ def check_intent(message, agent_name:, channel: "conversation", context: nil)
     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
+  # Deterministic conversational-flow check: use last-responder detection to
+  # resolve the common case without hitting the LLM at all.
+  last_responder = detect_last_responder_name(context)
+
+  if last_responder
+    is_acknowledgment = message.strip.match?(ACKNOWLEDGMENT_PATTERN)
+
+    if last_responder.downcase == agent_name.downcase
+      # This agent was the last to speak — human is continuing with us
+      if is_acknowledgment
+        LOG.info "[Intent] Deterministic skip for #{agent_name} — pure acknowledgment, no action needed"
+        return false
+      end
+      LOG.info "[Intent] Deterministic respond for #{agent_name} — was last to speak, human continues"
+      return true
+    else
+      # A different agent was the last to speak — this message is probably for them
+      # UNLESS it explicitly names this agent (already checked above via intent_names_other_agent? for OTHER agents,
+      # but also check if it mentions THIS agent's name directly)
+      if message_mentions_agent?(message, agent_name)
+        LOG.info "[Intent] Deterministic respond for #{agent_name} — named in message despite #{last_responder} speaking last"
+        return true
+      end
+      LOG.info "[Intent] Deterministic skip for #{agent_name} — #{last_responder} was last to speak"
+      return false
+    end
+  end
+
+  # No clear last responder detected — fall through to LLM for classification.
+  classify_intent_via_llm(message, agent_name:, channel:, config:)
+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
+end
 
-  # Build agent roster for the prompt so the model knows which names are agents
+# Fall through to LLM for intent classification when deterministic checks are inconclusive.
+# This handles cases like: no agents have spoken yet, or context is unavailable.
+def classify_intent_via_llm(message, agent_name:, channel:, config:)
   roster_block = build_intent_agent_roster(agent_name)
+  last_responder_block = "No agent has spoken recently."
 
   prompt = INTENT_PROMPT_TEMPLATE
            .gsub("{{AGENT_NAME}}", agent_name)
-           .gsub("{{CHANNEL}}", channel)
            .gsub("{{AGENT_ROSTER}}", roster_block)
-           .gsub("{{CONTEXT}}", context_block)
+           .gsub("{{LAST_RESPONDER}}", last_responder_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)
+  response = query_local_llm(prompt, config, system: "Answer yes or no only.")
   result = positive_intent?(response)
   LOG.info "[Intent] Result for #{agent_name}: #{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
 end
 
 # Query the local LLM via Ollama's HTTP API.
 #
 # @param prompt [String] The classification prompt
 # @param config [Hash] Intent configuration
+# @param system [String, nil] Optional system message for output format control
 # @return [String] Raw response text from the model
-def query_local_llm(prompt, config)
-  uri = URI(config["endpoint"])
+def query_local_llm(prompt, config, system: nil)
+  endpoint = config["endpoint"]
+  # Use /api/chat with think:false to disable thinking mode on models like Qwen3.
+  # The /api/generate endpoint always uses thinking tokens, which generates hundreds
+  # of hidden tokens for a simple yes/no answer (2.5s+ vs 0.2s with think:false).
+  chat_uri = URI(endpoint.sub(%r{/api/generate\z}, "/api/chat"))
+
+  messages = []
+  messages << { role: "system", content: system } if system
+  messages << { role: "user", content: prompt }
+
   payload = {
     model: config["model"],
-    prompt: prompt,
+    messages: messages,
     stream: false,
-    options: { temperature: config["temperature"] }
+    think: false,
+    options: { temperature: config["temperature"], num_predict: 5 }
   }
 
-  http = Net::HTTP.new(uri.host, uri.port)
+  http = Net::HTTP.new(chat_uri.host, chat_uri.port)
   http.open_timeout = config["timeout"]
   http.read_timeout = config["timeout"]
 
-  request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  request = Net::HTTP::Post.new(chat_uri.path, "Content-Type" => "application/json")
   request.body = JSON.generate(payload)
 
   response = http.request(request)
@@ -222,9 +249,9 @@ def query_local_llm(prompt, config)
   end
 
   body = JSON.parse(response.body)
-  body["response"] || ""
+  body.dig("message", "content") || ""
 rescue Errno::ECONNREFUSED
-  raise "Ollama not running at #{config["endpoint"]}. Start it with: ollama serve"
+  raise "Ollama not running at #{endpoint}. Start it with: ollama serve"
 rescue Net::OpenTimeout, Net::ReadTimeout
   raise "Ollama timed out after #{config["timeout"]}s"
 end
@@ -360,18 +387,94 @@ def directly_addressed_to?(msg, name)
 end
 
 # Build a compact agent roster string for the intent prompt.
-# Helps the LLM identify which names in the conversation are agents.
+# Returns a comma-separated list of agent display names.
 #
-# @param agent_name [String] The current agent (highlighted)
-# @return [String] Formatted roster for prompt injection
+# @param agent_name [String] The current agent (unused but kept for interface consistency)
+# @return [String] Comma-separated agent names
 def build_intent_agent_roster(agent_name)
-  return "" unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+  return agent_name 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
+  return agent_name if names.empty?
+
+  names.join(", ")
+end
+
+# Detect the last agent to respond in the conversation context.
+# Returns a prompt-friendly string telling the model who was last to respond.
+#
+# The context is formatted as "username: message\n..." lines.
+# We scan backwards to find the most recent line authored by a known agent.
+#
+# @param context [String, nil] Conversation history
+# @param agent_name [String] The current agent being evaluated
+# @return [String] Prompt block describing the last responder
+def detect_last_responder(context, _agent_name = nil)
+  return "No agent has spoken yet." if context.nil? || context.strip.empty?
+  return "No agent has spoken yet." unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  # Build a lookup of agent display names (lowercase) to their proper display name
+  agent_names = {}
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    agent_names[display.downcase] = display
+  end
+
+  # Scan context lines in reverse to find the last agent message
+  lines = context.strip.lines.reverse
+  lines.each do |line|
+    # Lines are formatted as "username: message content"
+    match = line.match(/\A(\S+?):\s/)
+    next unless match
+
+    username = match[1].downcase
+    next unless agent_names.key?(username)
+
+    responder = agent_names[username]
+    return "#{responder} was the last to speak. The human is continuing the conversation with #{responder}."
+  end
+
+  "No agent has spoken yet."
+end
+
+# Detect the last agent to respond — returns just the display name (or nil).
+# Used for deterministic conversational-flow checks without LLM involvement.
+#
+# @param context [String, nil] Conversation history
+# @return [String, nil] Display name of last agent to speak, or nil
+def detect_last_responder_name(context)
+  return nil if context.nil? || context.strip.empty?
+  return nil unless defined?(AGENT_REGISTRY) && !AGENT_REGISTRY.empty?
+
+  agent_names = {}
+  AGENT_REGISTRY.each do |key, entry|
+    display = entry.is_a?(Hash) ? (entry["display_name"] || key.capitalize) : key.capitalize
+    agent_names[display.downcase] = display
+  end
+
+  context.strip.lines.reverse_each do |line|
+    match = line.match(/\A(\S+?):\s/)
+    next unless match
+
+    username = match[1].downcase
+    return agent_names[username] if agent_names.key?(username)
+  end
+
+  nil
+end
+
+# Check if a message contains a direct reference to a specific agent's name.
+# More permissive than intent_names_other_agent? — catches any occurrence of the name.
+#
+# @param message [String] The message text
+# @param agent_name [String] The agent name to look for
+# @return [Boolean] true if the agent is mentioned by name
+def message_mentions_agent?(message, agent_name)
+  return false if message.nil? || agent_name.nil?
 
-  "Known agents in this system: #{names.join(", ")}. You are routing for #{agent_name}."
+  escaped = Regexp.escape(agent_name)
+  message.match?(/\b#{escaped}\b/i)
 end

data/lib/brainiac/version.rb

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

metadata

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