brainiac 0.0.5 → 0.0.7

data/monitor/setup-waybar-deployments.rb

@@ -1,96 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# One-time setup: adds Brainiac deployments module to waybar config
-# and repositions the agent session module with more breathing room.
-
-require "json"
-
-WAYBAR_CONFIG = File.expand_path("~/.config/waybar/config.jsonc")
-DEPLOY_SCRIPT = File.expand_path("~/Code/brainiac/monitor/waybar-deployments.rb")
-WAYBAR_STYLE  = File.expand_path("~/.config/waybar/style.css")
-
-def load_config
-  content = File.read(WAYBAR_CONFIG)
-  json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
-  JSON.parse(json_content)
-end
-
-def save_config(config)
-  File.write(WAYBAR_CONFIG, JSON.pretty_generate(config))
-end
-
-config = load_config
-
-# Remove any existing deployment module
-config["modules-center"]&.reject! { |m| m.to_s.include?("brainiac-deploy") }
-config["modules-right"]&.reject! { |m| m.to_s.include?("brainiac-deploy") }
-config.delete("custom/brainiac-deployments")
-
-# Move agent session module from modules-right to modules-center (after indicators)
-if config["modules-right"]&.delete("custom/brainiac")
-  config["modules-center"] ||= []
-  config["modules-center"] << "custom/brainiac" unless config["modules-center"].include?("custom/brainiac")
-end
-
-# Add deployments module right before agent sessions in modules-center
-center = config["modules-center"] || []
-zc_idx = center.index("custom/brainiac")
-if zc_idx
-  center.insert(zc_idx, "custom/brainiac-deployments") unless center.include?("custom/brainiac-deployments")
-else
-  center << "custom/brainiac-deployments" unless center.include?("custom/brainiac-deployments")
-end
-
-# Add module config
-config["custom/brainiac-deployments"] = {
-  "exec" => DEPLOY_SCRIPT,
-  "return-type" => "json",
-  "interval" => 30,
-  "format" => "{}",
-  "tooltip" => true,
-  "format-alt" => "{}",
-  "escape" => false,
-  "on-click" => "#{DEPLOY_SCRIPT} --click",
-  "on-click-right" => "#{DEPLOY_SCRIPT} --deploy"
-}
-
-save_config(config)
-
-# Add CSS for the deployments module
-style = File.read(WAYBAR_STYLE)
-unless style.include?("#custom-brainiac-deployments")
-  css = <<~CSS
-
-    /* Brainiac deployment environment dots */
-    #custom-brainiac-deployments {
-      margin-left: 100px;
-      margin-right: 40px;
-      font-size: 14px;
-    }
-  CSS
-  File.write(WAYBAR_STYLE, style + css)
-  puts "✓ Added deployment styles to waybar CSS"
-end
-
-# Add padding-right to agent sessions module
-unless style.include?("padding-right") && style.include?("#custom-brainiac")
-  updated_style = File.read(WAYBAR_STYLE)
-  if updated_style.include?("#custom-brainiac {")
-    updated_style.sub!(/(#custom-brainiac\s*\{[^}]*)(\})/) do
-      block = Regexp.last_match(1)
-      close = Regexp.last_match(2)
-      if block.include?("padding-right")
-        "#{block}#{close}"
-      else
-        "#{block}\n  padding-right: 100px;\n#{close}"
-      end
-    end
-    File.write(WAYBAR_STYLE, updated_style)
-    puts "✓ Added padding-right to agent session module"
-  end
-end
-
-puts "✓ Deployments module added to waybar config"
-puts "  Positioned: [deploy-dots] [agent-sessions] in center bar"
-puts "  Restart waybar to apply: omarchy restart waybar"

data/monitor/setup-waybar-module.rb

@@ -1,113 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# One-time setup script to add Brainiac module to waybar config
-# Run this once, then the module will update dynamically without config rewrites
-
-require "json"
-require "fileutils"
-
-WAYBAR_CONFIG = File.expand_path("~/.config/waybar/config.jsonc")
-WAYBAR_SCRIPT = File.expand_path("~/.brainiac/bin/waybar-status")
-
-# Create a wrapper script that resolves the running server's waybar.rb dynamically
-wrapper_dir = File.expand_path("~/.brainiac/bin")
-FileUtils.mkdir_p(wrapper_dir)
-wrapper_path = File.join(wrapper_dir, "waybar-status")
-File.write(wrapper_path, <<~SCRIPT)
-  #!/usr/bin/env ruby
-  # Resolves the running Brainiac server's waybar module dynamically.
-  # This allows worktrees / branches to work without reconfiguring waybar.
-
-  root_file = File.expand_path("~/.brainiac/server.root")
-  if File.exist?(root_file)
-    server_root = File.read(root_file).strip
-    waybar_script = File.join(server_root, "monitor", "waybar.rb")
-    if File.exist?(waybar_script)
-      load waybar_script
-      exit
-    end
-  end
-
-  # Fallback: no server root known, try the API directly
-  require "json"
-  require "net/http"
-
-  begin
-    uri = URI("http://localhost:4567/api/status")
-    response = Net::HTTP.get_response(uri)
-    if response.is_a?(Net::HTTPSuccess)
-      data = JSON.parse(response.body)
-      sessions = data["sessions"] || []
-      if sessions.empty?
-        puts({ text: "💤", tooltip: "No active agent sessions", class: "idle" }.to_json)
-      else
-        puts({ text: "🟢 \#{sessions.size}", tooltip: sessions.map { |s| s["agent"] }.join(", "), class: "working" }.to_json)
-      end
-    else
-      puts({ text: "⚠️", tooltip: "Brainiac Error: HTTP \#{response.code}", class: "error" }.to_json)
-    end
-  rescue StandardError => e
-    puts({ text: "⚠️", tooltip: "Brainiac Error: \#{e.message}", class: "error" }.to_json)
-  end
-SCRIPT
-File.chmod(0o755, wrapper_path)
-
-def load_config
-  content = File.read(WAYBAR_CONFIG)
-  # Strip comments for JSON parsing
-  json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
-  JSON.parse(json_content)
-end
-
-def save_config(config)
-  File.write(WAYBAR_CONFIG, JSON.pretty_generate(config))
-end
-
-# Load current config
-config = load_config
-
-# Remove old brainiac modules if they exist (from all module arrays)
-%w[modules-left modules-center modules-right].each do |section|
-  next unless config[section].is_a?(Array)
-
-  config[section].reject! { |m| ["custom/brainiac", "group/brainiac-agents"].include?(m.to_s) }
-end
-config.each_key do |key|
-  config.delete(key) if ["custom/brainiac", "group/brainiac-agents"].include?(key.to_s)
-end
-
-# Add single dynamic module at the end of modules-center (after deploy envs)
-config["modules-center"] ||= []
-config["modules-center"].push("custom/brainiac")
-
-# Add module config
-config["custom/brainiac"] = {
-  "exec" => WAYBAR_SCRIPT,
-  "return-type" => "json",
-  "interval" => 3,
-  "format" => "{}",
-  "tooltip" => true,
-  "on-click" => File.expand_path("~/.brainiac/bin/waybar-logs").to_s
-}
-
-# Create on-click wrapper too
-logs_wrapper = File.expand_path("~/.brainiac/bin/waybar-logs")
-File.write(logs_wrapper, <<~SCRIPT)
-  #!/usr/bin/env ruby
-  root_file = File.expand_path("~/.brainiac/server.root")
-  if File.exist?(root_file)
-    server_root = File.read(root_file).strip
-    script = File.join(server_root, "monitor", "view-logs-rofi.rb")
-    exec("ruby", script) if File.exist?(script)
-  end
-  warn "Brainiac server root not found"
-SCRIPT
-File.chmod(0o755, logs_wrapper)
-
-# Save updated config
-save_config(config)
-
-puts "✓ Brainiac module added to waybar config"
-puts "  Module will update every 3 seconds without config rewrites"
-puts "  Restart waybar to apply: omarchy restart waybar"

data/monitor/setup-xbar-plugin.rb

@@ -1,35 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# One-time setup: symlinks the Brainiac xbar plugin into xbar's plugin directory
-# Run this once on macOS after installing xbar
-
-require "fileutils"
-
-XBAR_PLUGIN_DIR = File.expand_path("~/Library/Application Support/xbar/plugins")
-PLUGIN_SOURCE = File.expand_path("xbar.3s.rb", __dir__)
-PLUGIN_DEST = File.join(XBAR_PLUGIN_DIR, "brainiac.3s.rb")
-
-unless RUBY_PLATFORM.match?(/darwin/i)
-  puts "⚠ This script is for macOS only (xbar doesn't run on Linux)"
-  exit 1
-end
-
-unless File.directory?(XBAR_PLUGIN_DIR)
-  puts "⚠ xbar plugin directory not found: #{XBAR_PLUGIN_DIR}"
-  puts "  Install xbar first: https://xbarapp.com"
-  exit 1
-end
-
-if File.exist?(PLUGIN_DEST)
-  puts "Removing existing plugin at #{PLUGIN_DEST}"
-  File.delete(PLUGIN_DEST)
-end
-
-File.symlink(PLUGIN_SOURCE, PLUGIN_DEST)
-File.chmod(0o755, PLUGIN_SOURCE)
-
-puts "✓ Brainiac xbar plugin installed"
-puts "  #{PLUGIN_SOURCE} → #{PLUGIN_DEST}"
-puts "  Refresh interval: 3 seconds"
-puts "  Restart xbar to activate"

data/monitor/view-logs.rb

@@ -1,119 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Brainiac Log Viewer
-# Shows a rofi menu to select which agent log to tail
-
-require "json"
-require "net/http"
-require "socket"
-
-SOCKET_PATH = "/tmp/brainiac-monitor.sock"
-API_URL = "http://localhost:4567/api/status"
-CONFIG_PATH = File.expand_path("~/.brainiac/waybar.json")
-
-# Load agent configuration from JSON
-def load_agent_config
-  config = JSON.parse(File.read(CONFIG_PATH))
-  agents = {}
-  config["agents"].each do |agent|
-    agents[agent["name"].downcase] = agent["emoji"]
-  end
-  default_emoji = config["default_emoji"] || "❓"
-  [agents, default_emoji]
-rescue StandardError => e
-  warn "Failed to load waybar.json: #{e.message}"
-  [{}, "❓"]
-end
-
-AGENTS, DEFAULT_EMOJI = load_agent_config
-
-def fetch_state_from_socket
-  socket = UNIXSocket.new(SOCKET_PATH)
-  data = socket.read
-  socket.close
-  JSON.parse(data)
-end
-
-def fetch_state_from_api
-  uri = URI(API_URL)
-  response = Net::HTTP.get_response(uri)
-  return nil unless response.is_a?(Net::HTTPSuccess)
-
-  JSON.parse(response.body)
-end
-
-def fetch_state
-  # Prefer socket (daemon mode) — faster, no HTTP overhead
-  fetch_state_from_socket
-rescue Errno::ENOENT, Errno::ECONNREFUSED
-  # Daemon not running — fall back to direct API call
-  data = fetch_state_from_api
-  unless data
-    puts "Error: Server not reachable"
-    exit 1
-  end
-  data
-rescue StandardError => e
-  puts "Error: #{e.message}"
-  exit 1
-end
-
-def format_elapsed(seconds)
-  return "#{seconds}s" if seconds < 60
-
-  minutes = seconds / 60
-  return "#{minutes}m" if minutes < 60
-
-  hours = minutes / 60
-  "#{hours}h"
-end
-
-state = fetch_state
-sessions = state["sessions"] || []
-
-if sessions.empty?
-  system("notify-send", "Brainiac", "No active agent sessions")
-  exit 0
-end
-
-# If only one session, open it directly
-if sessions.size == 1
-  log_file = sessions[0]["log_file"]
-  exec("alacritty", "-e", "tail", "-f", log_file) if log_file
-  exit 0
-end
-
-# Multiple sessions: use fzf if available, otherwise just open the first one
-if system("which fzf > /dev/null 2>&1")
-  # Build fzf menu
-  options = sessions.map do |s|
-    agent = s["agent"]
-    elapsed = format_elapsed(s["elapsed_seconds"])
-
-    card_key = s["card_key"]
-    context = if card_key.start_with?("discord-")
-                "Discord chat"
-              elsif card_key.start_with?("card-")
-                card_key.split("-")[1]
-              else
-                card_key
-              end
-
-    emoji = AGENTS[agent.downcase] || DEFAULT_EMOJI
-
-    "#{emoji} #{agent}: #{context} (#{elapsed})|#{s["log_file"]}"
-  end
-
-  menu_text = options.join("\n")
-  selected = `echo "#{menu_text}" | fzf --prompt="Agent Logs: "`.strip
-
-  unless selected.empty?
-    log_file = selected.split("|").last
-    exec("alacritty", "-e", "tail", "-f", log_file)
-  end
-else
-  # No menu system, just open the first log
-  log_file = sessions[0]["log_file"]
-  exec("alacritty", "-e", "tail", "-f", log_file) if log_file
-end

data/monitor/waybar-config-updater.rb

@@ -1,56 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Brainiac Waybar Config Updater
-# Dynamically updates waybar config with per-agent modules
-
-require "json"
-
-WAYBAR_CONFIG = File.expand_path("~/.config/waybar/config.jsonc")
-WAYBAR_SCRIPT = File.expand_path("~/Code/brainiac/monitor/waybar.rb")
-
-def load_config
-  content = File.read(WAYBAR_CONFIG)
-  # Strip comments for JSON parsing
-  json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
-  JSON.parse(json_content)
-end
-
-def save_config(config)
-  File.write(WAYBAR_CONFIG, JSON.pretty_generate(config))
-end
-
-def brainiac_modules
-  output = `#{WAYBAR_SCRIPT} --config`
-  JSON.parse(output)
-end
-
-# Load current config
-config = load_config
-
-# Get dynamic Brainiac modules
-brainiac_data = brainiac_modules
-modules = brainiac_data["modules"]
-module_configs = brainiac_data["config"]
-
-# Remove old brainiac modules and groups from modules-right
-config["modules-right"].reject! { |m| m.to_s.start_with?("custom/brainiac") || m.to_s == "group/brainiac-agents" }
-
-# Insert new modules at the beginning of modules-right
-config["modules-right"] = modules + config["modules-right"]
-
-# Remove old brainiac module configs and groups
-config.each_key do |key|
-  config.delete(key) if key.to_s.start_with?("custom/brainiac") || key.to_s == "group/brainiac-agents"
-end
-
-# Add new module configs
-module_configs.each do |name, cfg|
-  config[name] = cfg
-end
-
-# Save updated config
-save_config(config)
-
-# Reload waybar
-system("killall", "-SIGUSR2", "waybar")

data/monitor/waybar-deployments.rb

@@ -1,239 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Brainiac Waybar Deployments Module
-# Polls /api/deployments and outputs JSON for waybar
-
-require "json"
-require "net/http"
-require "shellwords"
-require "uri"
-require "time"
-
-SERVER_URL = "http://localhost:4567"
-
-def fetch_deployments
-  uri = URI("#{SERVER_URL}/api/deployments")
-  response = Net::HTTP.get_response(uri)
-  JSON.parse(response.body)["deployments"] || []
-rescue StandardError
-  nil
-end
-
-def time_ago(iso_time)
-  return nil unless iso_time
-
-  seconds = (Time.now - Time.parse(iso_time)).to_i
-  return "#{seconds}s ago" if seconds < 60
-
-  minutes = seconds / 60
-  return "#{minutes}m ago" if minutes < 60
-
-  hours = minutes / 60
-  return "#{hours}h ago" if hours < 24
-
-  "#{hours / 24}d ago"
-end
-
-def generate_output
-  deployments = fetch_deployments
-  unless deployments
-    puts({ text: "", tooltip: "Deploy tracker: server unreachable", class: "error" }.to_json)
-    return
-  end
-
-  if deployments.empty?
-    puts({ text: "", tooltip: "No environments configured", class: "empty" }.to_json)
-    return
-  end
-
-  recent_window = 30 * 60 # 30 minutes
-
-  dots = deployments.map do |d|
-    if d["status"] == "occupied"
-      deploy_time = d["last_deploy_at"] || d["deployed_at"]
-      recent = deploy_time && (Time.now - Time.parse(deploy_time)) < recent_window
-      status = d["last_deploy_status"]
-
-      if status == "failed"
-        '<span color="#ff4444" background="#440000">●</span>'
-      elsif recent && status == "success"
-        '<span color="#4488ff">●</span>'
-      else
-        '<span color="#ff4444">●</span>'
-      end
-    else
-      '<span color="#44ff44">●</span>'
-    end
-  end
-  text = dots.join(" ")
-
-  # Determine CSS class based on deploy states
-  has_recent_success = deployments.any? do |d|
-    t = d["last_deploy_at"] || d["deployed_at"]
-    d["last_deploy_status"] == "success" && t && (Time.now - Time.parse(t)) < recent_window
-  end
-  has_failure = deployments.any? { |d| d["last_deploy_status"] == "failed" }
-
-  css_class = if has_failure
-                "deploy-failed"
-              elsif has_recent_success
-                "deploy-recent"
-              else
-                "deployments"
-              end
-
-  tooltip_lines = deployments.map do |d|
-    label = d["label"] || d["env"]
-    if d["status"] == "occupied"
-      card = d["card_number"] ? "##{d["card_number"]}" : d["branch"] || "unknown"
-      branch = d["branch"] ? " — #{d["branch"]}" : ""
-      ago = time_ago(d["deployed_at"])
-      status_icon = case d["last_deploy_status"]
-                    when "failed" then "💥"
-                    when "success"
-                      t = d["last_deploy_at"] || d["deployed_at"]
-                      t && (Time.now - Time.parse(t)) < recent_window ? "🚀✅" : "🔴"
-                    else "🔴"
-                    end
-      "#{status_icon} #{label}: #{card}#{branch}#{" (#{ago})" if ago}"
-    else
-      ago = time_ago(d["cleared_at"])
-      last = d["last_card"] ? " (was ##{d["last_card"]})" : ""
-      "🟢 #{label}: Available#{" #{ago}" if ago}#{last}"
-    end
-  end
-
-  puts({ text: text, tooltip: tooltip_lines.join("\n"), class: css_class }.to_json)
-end
-
-def resize_deploy_terminal
-  script = "sleep 0.5 && " \
-           'width=$(hyprctl monitors -j | ruby -rjson -e "puts JSON.parse(STDIN.read)[0][%q(width)]") && ' \
-           "delta=$(( (width / 2) - (width * 15 / 100) )) && " \
-           'hyprctl --batch "dispatch focuswindow class:brainiac-deploy; dispatch resizeactive -${delta} 0"'
-  spawn("bash", "-c", script, %i[out err] => "/dev/null")
-end
-
-def handle_click
-  deployments = fetch_deployments
-  return unless deployments&.any?
-
-  # If any environment has a failed deploy, show the log
-  failed = deployments.find { |d| d["last_deploy_status"] == "failed" && d["last_deploy_log"] }
-  if failed && File.exist?(failed["last_deploy_log"].to_s)
-    spawn("alacritty", "-e", "bash", "-c",
-          "echo '=== Deploy failure: #{failed["label"] || failed["env"]} ===' && echo && cat #{Shellwords.escape(failed["last_deploy_log"])} && echo && echo 'Press Enter to close...' && read",
-          %i[out err] => "/dev/null")
-    return
-  end
-
-  # Otherwise open environment URLs
-  options = deployments.filter_map do |d|
-    url = d["url"]
-    next unless url
-
-    label = d["label"] || d["env"]
-    status = d["status"] == "occupied" ? "🔴" : "🟢"
-    card = d["card_number"] ? " ##{d["card_number"]}" : ""
-    ["#{status} #{label}#{card}", url]
-  end
-  return if options.empty?
-
-  if options.length == 1
-    spawn("xdg-open", options[0][1], %i[out err] => "/dev/null")
-  else
-    labels = options.map(&:first)
-    choice = `timeout 30 zenity --list --title="Open Environment" --column="Environment" #{labels.map do |l|
-      Shellwords.escape(l)
-    end.join(" ")} 2>/dev/null`.strip
-    return if choice.empty?
-
-    selected = options.find { |label, _| label == choice }
-    spawn("xdg-open", selected[1], %i[out err] => "/dev/null") if selected
-  end
-end
-
-def handle_deploy
-  deployments = fetch_deployments
-  return unless deployments&.any?
-
-  # Pick environment
-  envs = deployments.map { |d| [d["env"], d["label"] || d["env"]] }
-  if envs.length == 1
-    env_key = envs[0][0]
-  else
-    labels = envs.map { |key, label| "#{key}|#{label}" }
-    choice = `timeout 30 zenity --list --title="Deploy to..." --column="Env" --column="Label" #{labels.map do |l|
-      l.split("|").map do |p|
-        Shellwords.escape(p)
-      end.join(" ")
-    end.join(" ")} 2>/dev/null`.strip
-    return if choice.empty?
-
-    env_key = choice
-  end
-
-  # Get card number — pre-fill with current card if environment is occupied
-  selected_dep = deployments.find { |d| d["env"] == env_key }
-  prefill = selected_dep && selected_dep["status"] == "occupied" && selected_dep["card_number"] ? selected_dep["card_number"].to_s : ""
-  card_number = `timeout 60 zenity --entry --title="Deploy to #{env_key}" --text="Fizzy card number:"#{unless prefill.empty?
-                                                                                                         " --entry-text=#{Shellwords.escape(prefill)}"
-                                                                                                       end} 2>/dev/null`.strip
-  return if card_number.empty?
-
-  # Resolve worktree via glob (same pattern as fz shell function)
-  matches = Dir.glob(File.expand_path("~/Code/*fizzy-#{card_number}-*/"))
-  worktree = matches.find { |d| File.directory?(d) }
-  unless worktree
-    `timeout 10 zenity --error --text="No worktree found for card ##{card_number}" 2>/dev/null`
-    return
-  end
-
-  deploy_script = <<~BASH
-    cd #{Shellwords.escape(worktree)}
-    echo "🚀 #{env_key} deploy in progress..."
-    echo
-    logfile=$(mktemp)
-    ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1 | tee "$logfile"
-    status=${PIPESTATUS[0]}
-    if [ $status -ne 0 ] && grep -q "checksums previously recorded in the dependency lock file" "$logfile"; then
-      echo
-      echo "⚠️  Terraform lock file mismatch — removing lock and running init -upgrade..."
-      echo
-      rm -f infrastructure/#{Shellwords.escape(env_key)}/.terraform.lock.hcl
-      (cd infrastructure/#{Shellwords.escape(env_key)} && terraform init -upgrade)
-      echo
-      echo "🔄 Retrying deploy..."
-      echo
-      ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1
-      status=$?
-    fi
-    rm -f "$logfile"
-    echo
-    if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
-    echo "Press Enter to close..."
-    read
-  BASH
-
-  # Mark deploying via API so waybar turns orange immediately
-  begin
-    uri = URI("#{SERVER_URL}/api/deployments/#{env_key}/deploying")
-    req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
-    req.body = { worktree: worktree }.to_json
-    Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
-  rescue StandardError
-    # Non-fatal — deploy proceeds even if server is unreachable
-  end
-
-  spawn("alacritty", "--class", "brainiac-deploy", "-e", "bash", "-c", deploy_script, %i[out err] => "/dev/null")
-  resize_deploy_terminal
-end
-
-if ARGV.include?("--click")
-  handle_click
-elsif ARGV.include?("--deploy")
-  handle_deploy
-else
-  generate_output
-end