brainiac 0.0.13 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 900af8a7e0c45dd36e8d3dd0eeebe9f72d5b31da6f97f55d847542aade0e8bec
-  data.tar.gz: e9c685222d55fb1820062f04b695c6c7233531b2198e4edd12a79c8013cbe3d8
+  metadata.gz: 677c29e7ddcf5d9718eda91175193e9ffa448be65fac5e698982009327ee3576
+  data.tar.gz: ec7c044b3661f5fdca2f462a305a53ab47c6cfd76299462fa5e3df0f83f28a3a
 SHA512:
-  metadata.gz: 8955a6fb660975dfac37f1772494e8d6d0aec2d09f4dd3a94715dd2357df111824557a2d475adeae2ff11d68ae6fedb1556c5bb3b8c397b46fafe75a5993c5c1
-  data.tar.gz: 620f1e0d10401ba5892d019d491c2fd2eda8d34098f9ab1729e9ba00bf434a6e0f1bb185b12b8ab329aad4d2745f0beb4fed7cffd5151bdb3d0c7cab090021c6
+  metadata.gz: e4f3c2af97935afe5666ae722629f2a6a15af09fef73cc8ef969a11eccbf9c315cf50831e293a381cc6d2f4b2a383bce03a3fb673c4f9294ab17cb11f3656270
+  data.tar.gz: f70117f73d55be6914223bca9cbe331e0e9ecdece704349b71eb0c40f35fdcc8da8d2fdcf9cf297b7d9fa7b91b45350a09de12271332fcac7a28cda0d984c91c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.13)
+    brainiac (0.0.15)
       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.13)
+  brainiac (0.0.15)
   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?
@@ -655,7 +714,8 @@ def list_projects
     default_marker = config["default"] ? " (default)" : ""
     puts "  #{key}#{default_marker}"
     puts "    Path: #{config["repo_path"]}"
-    puts "    Tags: #{config["tags"] || config["project_tags"].join(", ")}"
+    tags = config["tags"] || config["project_tags"]&.join(", ")
+    puts "    Tags: #{tags}" if tags
     puts "    GitHub: #{config["github_repo"]}" if config["github_repo"]
     puts "    Agent: #{config["agent_cli"]} (model: #{config["agent_model"]})"
     puts
@@ -1872,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
@@ -1893,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]
@@ -2295,54 +2367,44 @@ when "update", "upgrade"
     end
 
     puts "Updating #{gem_name}..."
-    system("gem install #{gem_name}")
-    unless $CHILD_STATUS.success?
+    output, status = Open3.capture2e("gem install #{gem_name}")
+    puts output
+    unless status.success?
       puts ""
       puts "Failed to update #{gem_name}."
       exit 1
     end
 
-    # Show version change
-    Gem::Specification.reset
-    new_version = begin
-      spec = Gem::Specification.find_by_name(gem_name)
-      spec.version.to_s
-    rescue Gem::MissingSpecError
-      "unknown"
-    end
+    # Parse installed version from gem install output
+    new_version = output[/Successfully installed #{Regexp.escape(gem_name)}-(\S+)/, 1]
 
-    if current_version && current_version == new_version
-      puts "✓ #{gem_name} is already at the latest version (#{new_version})"
-    else
+    if new_version
       puts "✓ Updated #{gem_name}: #{current_version || "new"} → #{new_version}"
       puts "  Restart the server to activate: brainiac restart"
+    else
+      puts "✓ #{gem_name} is already at the latest version (#{current_version})"
     end
   else
     # Update brainiac itself: brainiac update
     current_version = BRAINIAC_VERSION
 
     puts "Updating brainiac gem..."
-    system("gem install brainiac")
-    unless $CHILD_STATUS.success?
+    output, status = Open3.capture2e("gem install brainiac")
+    puts output
+    unless status.success?
       puts ""
       puts "Failed to update brainiac."
       exit 1
     end
 
-    # Show version change
-    Gem::Specification.reset
-    new_version = begin
-      spec = Gem::Specification.find_by_name("brainiac")
-      spec.version.to_s
-    rescue Gem::MissingSpecError
-      "unknown"
-    end
+    # Parse installed version from gem install output
+    new_version = output[/Successfully installed brainiac-(\S+)/, 1]
 
-    if current_version == new_version
-      puts "✓ brainiac is already at the latest version (#{new_version})"
-    else
+    if new_version
       puts "✓ Updated brainiac: #{current_version} → #{new_version}"
       puts "  Restart the server to apply: brainiac restart"
+    else
+      puts "✓ brainiac is already at the latest version (#{current_version})"
     end
   end
 

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/config.rb

@@ -38,15 +38,48 @@ end
 BRAINIAC_CONFIG = load_brainiac_config
 
 # --- Default agent name ---
-# Priority: AI_AGENT_NAME env var → brainiac.json "default_agent" → error.
-AI_AGENT_NAME = ENV.fetch("AI_AGENT_NAME", nil) || BRAINIAC_CONFIG["default_agent"] || begin
+# Priority: AI_AGENT_NAME env var → brainiac.json "default_agent" → first agent in agents.json → error.
+def resolve_default_agent
+  # 1. Env var
+  name = ENV.fetch("AI_AGENT_NAME", nil)
+  return name if name
+
+  # 2. brainiac.json
+  name = BRAINIAC_CONFIG["default_agent"]
+  return name if name
+
+  # 3. First agent in agents.json
+  if File.exist?(AGENT_REGISTRY_FILE)
+    agents = begin
+      JSON.parse(File.read(AGENT_REGISTRY_FILE))
+    rescue StandardError
+      {}
+    end
+    first_agent = agents.values.first
+    if first_agent
+      agent_name = first_agent["fizzy_name"] || first_agent["display_name"] || agents.keys.first.capitalize
+      warn <<~MSG
+        [Brainiac] No default agent configured — using "#{agent_name}" (first agent in agents.json).
+        To set explicitly, either:
+          export AI_AGENT_NAME="#{agent_name}"
+        Or add to ~/.brainiac/brainiac.json:
+          { "default_agent": "#{agent_name}" }
+      MSG
+      return agent_name
+    end
+  end
+
+  # 4. Nothing found
   raise <<~MSG
-    No default agent configured. Set one of:
+    No default agent configured and no agents found in #{AGENT_REGISTRY_FILE}.
+    Set one of:
       1. Environment variable: export AI_AGENT_NAME="YourAgent"
       2. In ~/.brainiac/brainiac.json: { "default_agent": "YourAgent" }
   MSG
 end
 
+AI_AGENT_NAME = resolve_default_agent
+
 LOG_LEVEL = ENV.fetch("LOG_LEVEL", "info").downcase
 LOG = Logger.new($stdout)
 LOG.level = case LOG_LEVEL

data/lib/brainiac/helpers.rb

@@ -399,8 +399,27 @@ def resolve_resume(resume, resolved, chdir)
   false
 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)
+  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)
+    LOG.info "[Intent] Skipping dispatch for #{agent_name} — message classified as not requiring response"
+    return true
+  end
+
+  false
+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)
+              source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
+              message: nil, channel: 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)
+
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]
   model ||= resolved["agent_model"]

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# Local LLM-based intent detection.
+#
+# Uses a lightweight local model (via Ollama) to classify whether an incoming
+# message requires an agent to respond. This saves expensive API tokens by
+# filtering out messages that are just humans chatting, reactions, or noise.
+#
+# Also detects when an agent's own response implies pending work — if the agent
+# said "I'll do X" but the session ended without completing the work, this
+# signals that the agent should be re-dispatched.
+#
+# Configuration (in ~/.brainiac/brainiac.json):
+#
+#   "intent": {
+#     "enabled": true,
+#     "endpoint": "http://localhost:11434/api/generate",
+#     "model": "gemma3:4b",
+#     "timeout": 10,
+#     "temperature": 0.1
+#   }
+#
+# Plugins use this via:
+#   requires_response = check_intent(message, agent_name: "Galen", context: "Discord thread")
+#   return unless requires_response
+#
+# Returns true (agent should respond), false (skip), or true on any failure
+# (fail-open so we never accidentally ignore a real request).
+
+INTENT_CONFIG_DEFAULTS = {
+  "enabled" => false,
+  "endpoint" => "http://localhost:11434/api/generate",
+  "model" => "gemma3:4b",
+  "timeout" => 10,
+  "temperature" => 0.1
+}.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.
+
+  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 starts with or addresses someone else by name (e.g., "Adam, ...", "Hey Sarah", "Effie, ...") → no (it's directed at that person, not {{AGENT_NAME}})
+  - 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 responding to or commenting on what someone OTHER than {{AGENT_NAME}} just said → no
+  - If uncertain, lean toward yes (better to respond unnecessarily than miss a request)
+
+  Respond with ONLY "yes" or "no" — nothing else.
+
+  Latest message:
+  {{MESSAGE}}
+PROMPT
+
+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.
+
+  Rules:
+  - If the agent says it will do something, is about to start work, or promises a follow-up action → yes
+  - If the agent is reporting completed work, summarizing what was done, or delivering a final answer → no
+  - If the agent is asking a clarifying question and waiting for a human response → no
+  - If the agent says things like "give me a sec", "I'll implement this", "let me do that", "working on it" → yes
+  - If uncertain, lean toward no (avoid unnecessary re-dispatches)
+
+  Respond with ONLY "yes" or "no" — nothing else.
+
+  Agent's message:
+  {{MESSAGE}}
+PROMPT
+
+# Load intent config from brainiac.json, merging with defaults.
+def intent_config
+  raw = BRAINIAC_CONFIG["intent"] || {}
+  INTENT_CONFIG_DEFAULTS.merge(raw)
+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")
+# @return [Boolean] true if the agent should respond, false if it can be skipped
+def check_intent(message, agent_name:, channel: "conversation")
+  config = intent_config
+  return true unless config["enabled"]
+  return true if message.nil? || message.strip.empty?
+
+  prompt = INTENT_PROMPT_TEMPLATE
+           .gsub("{{AGENT_NAME}}", agent_name)
+           .gsub("{{CHANNEL}}", channel)
+           .gsub("{{MESSAGE}}", message.strip)
+
+  LOG.info "[Intent] Checking intent for #{agent_name} (#{channel}): #{message.strip.slice(0, 80)}..."
+  response = query_local_llm(prompt, config)
+  result = positive_intent?(response)
+  LOG.info "[Intent] Result: #{result ? "RESPOND" : "SKIP"} (model: #{config["model"]})"
+  result
+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
+# @return [String] Raw response text from the model
+def query_local_llm(prompt, config)
+  uri = URI(config["endpoint"])
+  payload = {
+    model: config["model"],
+    prompt: prompt,
+    stream: false,
+    options: { temperature: config["temperature"] }
+  }
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.open_timeout = config["timeout"]
+  http.read_timeout = config["timeout"]
+
+  request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  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)
+
+  body = JSON.parse(response.body)
+  body["response"] || ""
+rescue Errno::ECONNREFUSED
+  raise "Ollama not running at #{config["endpoint"]}"
+rescue Net::OpenTimeout, Net::ReadTimeout
+  raise "Ollama timed out after #{config["timeout"]}s"
+end
+
+# Parse the LLM's yes/no response into a boolean.
+# Fail-open: anything that isn't clearly "no" returns true.
+#
+# @param response [String] Raw response from the model
+# @return [Boolean]
+def positive_intent?(response)
+  cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
+  cleaned != "no"
+end
+
+# Check whether an agent's own message implies pending work that wasn't completed.
+# Used to detect when an agent posted "I'll do X" but the session ended without
+# actually doing the work — signaling the agent should be re-dispatched.
+#
+# Fail-closed: returns false on any error (don't re-dispatch on classification failure).
+#
+# @param message [String] The agent's posted message
+# @param agent_name [String] The agent who posted it
+# @return [Boolean] true if the message implies uncommitted work
+def check_pending_work(message, agent_name:)
+  config = intent_config
+  return false unless config["enabled"]
+  return false if message.nil? || message.strip.empty?
+
+  prompt = PENDING_WORK_PROMPT_TEMPLATE
+           .gsub("{{AGENT_NAME}}", agent_name)
+           .gsub("{{MESSAGE}}", message.strip)
+
+  response = query_local_llm(prompt, config)
+  result = pending_work_detected?(response)
+  LOG.info "[Intent] Pending work detected in #{agent_name}'s message" if result
+  result
+rescue StandardError => e
+  LOG.warn "[Intent] Pending work check failed (fail-closed): #{e.message}"
+  false
+end
+
+# Parse the LLM's yes/no response for pending work detection.
+# Fail-closed: anything that isn't clearly "yes" returns false.
+#
+# @param response [String] Raw response from the model
+# @return [Boolean]
+def pending_work_detected?(response)
+  cleaned = response.to_s.strip.downcase.gsub(/[^a-z]/, "")
+  cleaned == "yes"
+end

data/lib/brainiac/routes/api.rb

@@ -354,6 +354,67 @@ post "/api/cron/reload" do
   { status: "reloaded", jobs: CRON_JOBS.size }.to_json
 end
 
+# --- Intent ---
+
+get "/api/intent/config" do
+  content_type :json
+  config = intent_config
+  status = if config["enabled"]
+             begin
+               uri = URI(config["endpoint"].sub("/api/generate", "/api/tags"))
+               http = Net::HTTP.new(uri.host, uri.port)
+               http.open_timeout = 3
+               http.read_timeout = 3
+               response = http.get(uri.path)
+               if response.is_a?(Net::HTTPSuccess)
+                 models = JSON.parse(response.body).fetch("models", []).map { |m| m["name"] }
+                 model_available = models.any? { |m| m.start_with?(config["model"].split(":").first) }
+                 model_available ? "ok" : "model_not_found"
+               else
+                 "ollama_error"
+               end
+             rescue Errno::ECONNREFUSED
+               "ollama_not_running"
+             rescue StandardError => e
+               "error: #{e.message}"
+             end
+           else
+             "disabled"
+           end
+  config.merge("status" => status).to_json
+end
+
+post "/api/intent/check" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  message = payload["message"]
+  agent = payload["agent"] || AI_AGENT_NAME
+  channel = payload["channel"] || "conversation"
+
+  halt 400, { error: "Missing 'message' field" }.to_json unless message && !message.empty?
+
+  result = check_intent(message, agent_name: agent, channel: channel)
+  { should_respond: result, agent: agent, channel: channel }.to_json
+end
+
+post "/api/intent/pending-work" do
+  content_type :json
+  request.body.rewind
+  payload = JSON.parse(request.body.read)
+
+  message = payload["message"]
+  agent = payload["agent"] || AI_AGENT_NAME
+
+  halt 400, { error: "Missing 'message' field" }.to_json unless message && !message.empty?
+
+  result = check_pending_work(message, agent_name: agent)
+  { pending_work: result, agent: agent }.to_json
+end
+
+# --- Cron Logs ---
+
 get "/api/cron/logs" do
   content_type :json
   job_id = params["id"]

data/lib/brainiac/version.rb

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

data/lib/brainiac.rb

@@ -7,6 +7,7 @@ require_relative "brainiac/skills"
 require_relative "brainiac/sessions"
 require_relative "brainiac/prompts"
 require_relative "brainiac/helpers"
+require_relative "brainiac/intent"
 require_relative "brainiac/cron"
 require_relative "brainiac/plugins"
 

data/receiver.rb

@@ -24,6 +24,7 @@ require_relative "lib/brainiac/helpers"
 require_relative "lib/brainiac/notifications"
 require_relative "lib/brainiac/cron"
 require_relative "lib/brainiac/restart"
+require_relative "lib/brainiac/intent"
 require_relative "lib/brainiac/plugins"
 require_relative "lib/brainiac/handlers/shared/git"
 require_relative "lib/brainiac/handlers/shared/inline_tags"
@@ -98,6 +99,11 @@ configure do
 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"]}"
+else
+  LOG.info "[Intent] Disabled (enable in brainiac.json → intent.enabled: true)"
+end
 
 # --- Dashboard authentication ---
 

data/templates/brainiac.json.example

@@ -1,3 +1,10 @@
 {
-  "default_agent": "Sherlock"
+  "default_agent": "Sherlock",
+  "intent": {
+    "enabled": false,
+    "endpoint": "http://localhost:11434/api/generate",
+    "model": "gemma3:4b",
+    "timeout": 10,
+    "temperature": 0.1
+  }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.15
 platform: ruby
 authors:
 - Andy Davis
@@ -133,6 +133,7 @@ files:
 - lib/brainiac/handlers/shared/inline_tags.rb
 - lib/brainiac/helpers.rb
 - lib/brainiac/hooks.rb
+- lib/brainiac/intent.rb
 - lib/brainiac/notifications.rb
 - lib/brainiac/plugins.rb
 - lib/brainiac/prompts.rb