brainiac 0.0.5 → 0.0.7

data/lib/brainiac/handlers/fizzy/dedup.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Card duplicate detection (card_published / card_triaged).
+#
+# When a new card is created, checks for similar existing cards using
+# trigram and semantic similarity. Posts a warning comment if duplicates found.
+
+def handle_card_published(payload)
+  eventable = payload["eventable"] || {}
+  card_number = eventable["number"]
+  title = eventable["title"] || ""
+  creator_name = payload.dig("creator", "name")
+  creator_id = payload.dig("creator", "id")
+  tags = eventable["tags"] || []
+
+  # Creator-based routing: only the machine whose local human created the card
+  # handles dedup. Requires `"local": true` on the human in fizzy.json authorized_users.
+  local_humans = FIZZY_CONFIG.fetch("authorized_users", []).select { |u| u["human"] && u["local"] }
+  if local_humans.empty?
+    LOG.info "[CardIndex] No local humans configured — skipping dedup, indexing only"
+    return index_card_only(card_number, title, creator_name, creator_id, tags)
+  end
+
+  unless local_humans.any? { |u| u["id"] == creator_id }
+    LOG.info "[CardIndex] Ignoring card ##{card_number} — creator '#{creator_name}' is not a local human"
+    return index_card_only(card_number, title, creator_name, creator_id, tags)
+  end
+
+  # Check for duplicates before indexing
+  similar = CARD_INDEX.find_similar_cards(title, exclude_number: card_number, tags: tags) if card_number
+  index_card_only(card_number, title, creator_name, creator_id, tags, skip_response: true)
+
+  if similar&.any?
+    post_duplicate_warning(card_number, title, tags, similar)
+    [200, { status: "duplicate_detected", card: card_number,
+            similar: similar.map { |s| { number: s[:number], score: s[:score].round(2) } } }.to_json]
+  else
+    LOG.info "[CardIndex] Card ##{card_number} '#{title}' indexed, no duplicates found"
+    [200, { status: "indexed", card: card_number }.to_json]
+  end
+end
+
+def index_card_only(card_number, title, creator_name, creator_id, tags, skip_response: false)
+  CARD_INDEX.index_card(number: card_number, title: title, creator_name: creator_name, creator_id: creator_id, tags: tags) if card_number
+  CARD_INDEX.save
+  CARD_INDEX.schedule_qmd_reindex
+  [200, { status: "indexed", card: card_number }.to_json] unless skip_response
+end
+
+def post_duplicate_warning(card_number, title, tags, similar)
+  best = similar.first
+  LOG.info "[CardIndex] Potential duplicate: ##{card_number} '#{title}' ≈ " \
+           "##{best[:number]} '#{best[:title]}' (score: #{best[:score].round(2)})"
+
+  project_result = identify_project_by_tags(tags)
+  return unless project_result
+
+  _project_key, project_config = project_result
+  repo_path = project_config["repo_path"]
+
+  Thread.new do
+    method_label = { trigram: "📝", semantic: "🧠", both: "📝🧠" }
+    dupes = similar.map do |s|
+      icon = method_label[s[:method]] || "📝"
+      "##{s[:number]} \"#{s[:title]}\" (#{(s[:score] * 100).round}% #{icon})"
+    end.join("\n- ")
+    body = "⚠️ **Possible duplicate detected:**\n- #{dupes}\n\n_📝 = text similarity, 🧠 = semantic similarity_"
+    run_cmd("fizzy", "comment", "create", "--card", card_number.to_s, "--body", body,
+            chdir: repo_path, env: default_fizzy_env)
+    LOG.info "[CardIndex] Posted duplicate warning on card ##{card_number}"
+  rescue StandardError => e
+    LOG.warn "[CardIndex] Failed to post duplicate warning: #{e.message}"
+  end
+end

data/lib/brainiac/handlers/fizzy/deploy.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# Fizzy deploy comment handler.
+#
+# When a comment is just "dev02" (or any dev\d+), deploy the card's
+# worktree to that environment. No agent dispatch — reactions only.
+
+def handle_deploy_comment(eventable, env_key, card_internal_id)
+  comment_id = eventable["id"]
+  card_info = load_card_map[card_internal_id]
+
+  # Validate environment exists
+  deploy_config = DEPLOYMENTS_CONFIG["environments"] || {}
+  unless deploy_config.key?(env_key)
+    LOG.warn "[Deploy] Unknown environment: #{env_key}"
+    return [200, { status: "ignored", reason: "unknown environment" }.to_json]
+  end
+
+  # Check environment ownership
+  env_owner = deploy_config[env_key]["owner"]
+  unless env_owner && env_owner.downcase == AI_AGENT_NAME.downcase
+    LOG.info "[Deploy] Skipping #{env_key} — owner is #{env_owner.inspect}, this machine is #{AI_AGENT_NAME}"
+    return [200, { status: "ignored", reason: env_owner ? "owned by #{env_owner}" : "no owner configured" }.to_json]
+  end
+
+  worktree = card_info&.dig("worktree")
+  card_number = card_info&.dig("number")
+
+  # If worktree doesn't exist locally, try to clone the branch from origin
+  if worktree.nil? || !File.directory?(worktree)
+    result = clone_branch_for_deploy(eventable, card_internal_id, card_info)
+    unless result
+      LOG.warn "[Deploy] Could not resolve or clone branch for card #{card_internal_id}"
+      return [200, { status: "ignored", reason: "no worktree and could not clone branch" }.to_json]
+    end
+    worktree = result[:worktree]
+    card_number = result[:card_number]
+  end
+
+  deploy_script = File.join(worktree, "scripts", "deploy.sh")
+  unless File.exist?(deploy_script)
+    LOG.warn "[Deploy] No deploy script at #{deploy_script}"
+    return [200, { status: "ignored", reason: "no deploy script" }.to_json]
+  end
+
+  LOG.info "[Deploy] Deploying card ##{card_number} worktree to #{env_key}"
+  mark_deploying(env_key, worktree_path: worktree)
+
+  Thread.new do
+    react_to_deploy(card_number, comment_id, worktree, "🚀")
+    run_deploy(env_key, card_number, comment_id, worktree)
+  rescue StandardError => e
+    LOG.error "[Deploy] Error deploying card ##{card_number} to #{env_key}: #{e.message}"
+    react_to_deploy(card_number, comment_id, worktree, "❌")
+  end
+
+  [200, { status: "deploying", card: card_number, env: env_key }.to_json]
+end
+
+def react_to_deploy(card_number, comment_id, worktree, emoji)
+  run_cmd("fizzy", "reaction", "create", "--card", card_number.to_s,
+          "--comment", comment_id.to_s, "--content", emoji,
+          chdir: worktree, env: default_fizzy_env)
+rescue StandardError => e
+  LOG.warn "[Deploy] Could not add reaction #{emoji}: #{e.message}"
+end
+
+def run_deploy(env_key, card_number, comment_id, worktree)
+  deploy_env = {}
+  aws_profile = DEPLOYMENTS_CONFIG.dig("environments", env_key, "aws_profile")
+  deploy_env["AWS_PROFILE"] = aws_profile if aws_profile
+
+  stdout, stderr, status = Open3.capture3(deploy_env, "./scripts/deploy.sh", env_key, chdir: worktree)
+
+  if !status.success? && terraform_lock_error?(stdout, stderr)
+    stdout, stderr, status = retry_deploy_with_init(deploy_env, env_key, card_number, worktree)
+  end
+
+  if status.success?
+    LOG.info "[Deploy] Successfully deployed card ##{card_number} to #{env_key}"
+    react_to_deploy(card_number, comment_id, worktree, "✅")
+    deploy_to_environment(env_key, worktree_path: worktree, deployed_by: "fizzy-comment")
+  else
+    LOG.error "[Deploy] Failed deploying card ##{card_number} to #{env_key}: #{stderr}"
+    react_to_deploy(card_number, comment_id, worktree, "❌")
+    record_deploy_failure(env_key, worktree_path: worktree, stdout: stdout, stderr: stderr)
+  end
+end
+
+def retry_deploy_with_init(deploy_env, env_key, card_number, worktree)
+  LOG.info "[Deploy] Terraform lock file mismatch for card ##{card_number} — retrying with init -upgrade"
+  infra_dir = File.join(worktree, "infrastructure", env_key)
+  lock_file = File.join(infra_dir, ".terraform.lock.hcl")
+  FileUtils.rm_f(lock_file)
+  Open3.capture3(deploy_env, "terraform", "init", "-upgrade", chdir: infra_dir) if File.directory?(infra_dir)
+  Open3.capture3(deploy_env, "./scripts/deploy.sh", env_key, chdir: worktree)
+end
+
+# Clone a remote branch locally for deploy when the worktree doesn't exist on this machine.
+# Returns { worktree:, card_number: } on success, nil on failure.
+def clone_branch_for_deploy(eventable, card_internal_id, card_info)
+  card_tags = eventable.dig("card", "tags") || []
+  project_result = identify_project_by_tags(card_tags)
+  unless project_result
+    LOG.warn "[Deploy] Cannot identify project for card #{card_internal_id}"
+    return nil
+  end
+  project_key, project_config = project_result
+  repo_path = project_config["repo_path"]
+
+  card_number = card_info&.dig("number")
+  card_number ||= resolve_card_number(card_internal_id, repo_path: repo_path)
+  unless card_number
+    LOG.warn "[Deploy] Cannot resolve card number for #{card_internal_id}"
+    return nil
+  end
+
+  debounced_repo_fetch(repo_path)
+  branches = run_cmd("git", "branch", "-r", "--list", "origin/fizzy-#{card_number}-*", chdir: repo_path).strip
+  branch = branches.lines.map(&:strip).first&.sub("origin/", "")
+  unless branch
+    LOG.warn "[Deploy] No remote branch matching fizzy-#{card_number}-* found"
+    return nil
+  end
+
+  worktree_path = File.join(File.dirname(repo_path), "#{File.basename(repo_path)}--#{branch}")
+
+  unless File.directory?(worktree_path)
+    branch_exists_locally = system("git", "rev-parse", "--verify", branch, chdir: repo_path, out: File::NULL, err: File::NULL)
+    if branch_exists_locally
+      run_cmd("git", "worktree", "add", worktree_path, branch, chdir: repo_path)
+    else
+      run_cmd("git", "worktree", "add", "--track", "-b", branch, worktree_path, "origin/#{branch}", chdir: repo_path)
+    end
+
+    trust_version_manager(worktree_path, chdir: worktree_path)
+    apply_worktree_includes(repo_path, worktree_path)
+    run_project_hook(repo_path, "worktree-setup", extra_env: { "WORKTREE_PATH" => worktree_path })
+  end
+
+  # Update card map
+  map = load_card_map
+  map[card_internal_id] ||= {}
+  map[card_internal_id].merge!("number" => card_number, "branch" => branch, "worktree" => worktree_path, "project" => project_key)
+  save_card_map(map)
+
+  LOG.info "[Deploy] Cloned branch #{branch} into worktree #{worktree_path} for card ##{card_number}"
+  { worktree: worktree_path, card_number: card_number }
+rescue StandardError => e
+  LOG.error "[Deploy] Failed to clone branch for card #{card_internal_id}: #{e.message}"
+  nil
+end

data/lib/brainiac/{deployments.rb → handlers/fizzy/deployments.rb}

@@ -81,8 +81,10 @@ def deploy_to_environment(env_key, worktree_path:, deployed_by: nil)
       entry["pr_url"]    = pr["url"]
     end
     # Store card tags for URL resolution (e.g. ops-web-app → ops URL)
-    card_idx = CARD_INDEX[card_entry["number"].to_s]
-    entry["card_tags"] = card_idx["tags"] if card_idx && card_idx["tags"]
+    if defined?(CARD_INDEX)
+      card_idx = CARD_INDEX[card_entry["number"].to_s]
+      entry["card_tags"] = card_idx["tags"] if card_idx && card_idx["tags"]
+    end
   else
     # No card map match — record branch from git
     branch = `git -C #{Shellwords.escape(worktree_path)} rev-parse --abbrev-ref HEAD 2>/dev/null`.strip