brainiac 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7890616cf0466e9c991c0e1209ff482eae548c205d151746c3f3065d2c239033
-  data.tar.gz: 76f04a3697a1070932a9754281828fb6d49869c3efe1b0efc9a89c98f3ee9bba
+  metadata.gz: 900af8a7e0c45dd36e8d3dd0eeebe9f72d5b31da6f97f55d847542aade0e8bec
+  data.tar.gz: e9c685222d55fb1820062f04b695c6c7233531b2198e4edd12a79c8013cbe3d8
 SHA512:
-  metadata.gz: 975a3cff959457bd2bf6f622010d3f016643f36aea981874e9424fb278666eda22441fd9f0e5938806849eaa4165f62c2f1c5fd1be10ad32b501afcecfacfb1a
-  data.tar.gz: 2c94aeefd3190ad1c8f074665486988d1b0440b4cb104a5dae39d670bb5559db0d5abeb64a4d4da132c6ff8e2d385e004ee26d11568a6eaf7313a822f854065d
+  metadata.gz: 8955a6fb660975dfac37f1772494e8d6d0aec2d09f4dd3a94715dd2357df111824557a2d475adeae2ff11d68ae6fedb1556c5bb3b8c397b46fafe75a5993c5c1
+  data.tar.gz: 620f1e0d10401ba5892d019d491c2fd2eda8d34098f9ab1729e9ba00bf434a6e0f1bb185b12b8ab329aad4d2745f0beb4fed7cffd5151bdb3d0c7cab090021c6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.12)
+    brainiac (0.0.13)
       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.12)
+  brainiac (0.0.13)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/README.md

@@ -43,7 +43,9 @@ All four channels support inline tags in message/comment text. Tags are stripped
 | ----------------------------------------------------------------------------- | ----- | ------- | ------ | ----------------------------------------------------------------------------------------------------- |
 | `[project:XYZ]`                                                               | —     | ✓       | —      | Override which project the agent works in (Discord only — Fizzy uses card tags, GitHub uses the repo) |
 | `[opus]` `[sonnet]` `[haiku]` `[deepseek]` `[minimax]` `[minimax21]` `[qwen]` | ✓     | ✓       | ✓      | Override the model for this dispatch                                                                  |
-| `[worktree:branch-name]`                                                      | ✓     | —       | —      | Direct the agent to a specific worktree instead of the card's default                                 |
+| `[worktree:branch-name]`                                                      | ✓     | ✓       | —      | Direct the agent to a specific worktree/branch (legacy syntax)                                        |
+| `[branch:branch-name]`                                                        | ✓     | ✓       | ✓      | Target an existing branch — reuses its worktree if a work item exists                                 |
+| `[workitem:wi-abc123]`                                                        | ✓     | ✓       | ✓      | Target a specific work item by ID — agent works in its worktree                                       |
 | `[plan]`                                                                      | ✓     | ✓       | —      | Activate planning mode — agent gathers requirements before coding                                     |
 
 Model keys come from the project's `allowed_models` config. Fizzy also supports model selection via card tags (e.g. adding an `opus` tag to the card).
@@ -868,6 +870,50 @@ curl http://localhost:4567/api/users/fladamd            # Find by identifier
 
 The registry reloads automatically on every webhook and via `POST /api/reload`.
 
+## Work Items
+
+Work items are the universal tracking unit in Brainiac — they connect a branch/worktree to one or more communication channels. A single work item can span Discord, Fizzy, and GitHub simultaneously.
+
+### Structure
+
+Work items are stored in `~/.brainiac/work_items.json`:
+
+```json
+{
+  "wi-a1b2c3d4": {
+    "id": "wi-a1b2c3d4",
+    "branch": "fizzy-42-fix-login",
+    "worktree": "/home/you/Code/marketplace--fizzy-42-fix-login",
+    "project": "marketplace",
+    "agent": "Sherlock",
+    "sources": {
+      "fizzy": { "card_internal_id": "uuid-here", "card_number": 42 },
+      "github": { "prs": [{"number": 8, "url": "https://github.com/org/repo/pull/8"}] },
+      "discord": { "thread_id": "1234567890" }
+    }
+  }
+}
+```
+
+The **branch** is the universal join key. When any channel needs to find a work item, it looks up by branch name. This means:
+
+- A Fizzy card assignment creates a work item with `sources.fizzy`
+- When a PR is opened for that branch, `sources.github` is attached automatically
+- A Discord `[branch:fizzy-42-fix-login]` message targets the same worktree
+
+### Targeting Work Items
+
+From Discord or any channel, use inline tags to target existing work items:
+
+- **`[branch:branch-name]`** — find the work item for this branch, work in its worktree
+- **`[workitem:wi-abc123]`** — target a work item by its ID directly
+
+This enables cross-channel workflows without creating duplicate worktrees.
+
+### Migration
+
+The old format (keyed by Fizzy card internal ID) is automatically migrated on first read. No manual intervention needed — existing `work_items.json` files are transparently upgraded to the new source-agnostic format.
+
 ## Worktree Management
 
 When a card is assigned, Brainiac creates a git worktree for the agent to work in. Two config files in the project root control how gitignored files are handled:

data/lib/brainiac/config.rb

@@ -5,6 +5,7 @@ require "openssl"
 require "open3"
 require "fileutils"
 require "logger"
+require "securerandom"
 require "net/http"
 require "uri"
 

data/lib/brainiac/handlers/shared/inline_tags.rb

@@ -3,7 +3,8 @@
 # Shared inline tag parsing for handler messages.
 #
 # Messages from any channel can contain inline tags like:
-#   [project:my-project], [opus], [effort:high], [cli:grok], [chat], [plan]
+#   [project:my-project], [opus], [effort:high], [cli:grok], [chat], [plan],
+#   [branch:feature-xyz], [workitem:wi-abc123]
 #
 # This module provides a single parser that extracts all tags and returns
 # a structured result with the cleaned text.
@@ -31,9 +32,21 @@ def parse_inline_tags(text)
     planning: false,
     deploy_intent: nil,
     worktree_override: nil,
+    work_item: nil,
+    branch_override: nil,
     clean_text: text.dup
   }
 
+  parse_value_tags(result)
+  parse_flag_tags(result)
+  parse_work_item_tags(result)
+  parse_model_tag(result)
+
+  result[:clean_text].strip!
+  result
+end
+
+def parse_value_tags(result)
   # [project:my-project]
   if (match = result[:clean_text].match(/\[project:(\S+)\]/i))
     result[:project] = match[1]
@@ -52,6 +65,14 @@ def parse_inline_tags(text)
     result[:clean_text].sub!(match[0], "")
   end
 
+  # [deploy] or [deploy:dev01]
+  if (match = result[:clean_text].match(/\[deploy(?::([^\]]+))?\]/i))
+    result[:deploy_intent] = match[1]&.strip&.downcase || :auto
+    result[:clean_text].sub!(match[0], "")
+  end
+end
+
+def parse_flag_tags(result)
   # [chat], [question], [?]
   if result[:clean_text].match?(/\[(chat|question|\?)\]/i)
     result[:chat_mode] = true
@@ -59,23 +80,35 @@ def parse_inline_tags(text)
   end
 
   # [plan]
-  if result[:clean_text].match?(/\[plan\]/i)
-    result[:planning] = true
-    result[:clean_text].sub!(/\[plan\]/i, "")
+  return unless result[:clean_text].match?(/\[plan\]/i)
+
+  result[:planning] = true
+  result[:clean_text].sub!(/\[plan\]/i, "")
+end
+
+def parse_work_item_tags(result)
+  # [worktree:branch-name] — legacy syntax, still supported
+  if (match = result[:clean_text].match(/\[worktree:([^\]]+)\]/))
+    result[:worktree_override] = match[1].strip
+    result[:clean_text].sub!(match[0], "")
   end
 
-  # [deploy] or [deploy:dev01]
-  if (match = result[:clean_text].match(/\[deploy(?::([^\]]+))?\]/i))
-    result[:deploy_intent] = match[1]&.strip&.downcase || :auto
+  # [branch:branch-name] — preferred syntax for targeting a branch/worktree
+  if (match = result[:clean_text].match(/\[branch:([^\]]+)\]/i))
+    result[:branch_override] = match[1].strip
+    # Also set worktree_override for backward compat with plugins that read it
+    result[:worktree_override] ||= result[:branch_override]
     result[:clean_text].sub!(match[0], "")
   end
 
-  # [worktree:branch-name]
-  if (match = result[:clean_text].match(/\[worktree:([^\]]+)\]/))
-    result[:worktree_override] = match[1].strip
+  # [workitem:wi-abc123] — target a specific work item by ID
+  if (match = result[:clean_text].match(/\[workitem:([^\]]+)\]/i))
+    result[:work_item] = match[1].strip
     result[:clean_text].sub!(match[0], "")
   end
+end
 
+def parse_model_tag(result)
   # Model tag: any remaining [word] that isn't a known tag — detected separately
   # because it depends on the project's allowed_models config. We just capture
   # the raw match here for the caller to resolve.
@@ -83,7 +116,4 @@ def parse_inline_tags(text)
     result[:model_tag] = match[1].downcase
     result[:clean_text].sub!(match[0], "")
   end
-
-  result[:clean_text].strip!
-  result
 end

data/lib/brainiac/helpers.rb

@@ -112,7 +112,8 @@ end
 def load_work_item_map
   return {} unless File.exist?(WORK_ITEM_MAP_FILE)
 
-  JSON.parse(File.read(WORK_ITEM_MAP_FILE))
+  raw = JSON.parse(File.read(WORK_ITEM_MAP_FILE))
+  migrate_work_item_map(raw)
 rescue JSON::ParserError
   {}
 end
@@ -121,6 +122,162 @@ def save_work_item_map(map)
   File.write(WORK_ITEM_MAP_FILE, JSON.pretty_generate(map))
 end
 
+# Migrate old-format work item maps (keyed by Fizzy card internal ID with flat structure)
+# to the new source-agnostic format (keyed by work item ID with sources hash).
+# Old format: { "fizzy-uuid" => { "number" => 42, "branch" => "...", "worktree" => "...", "project" => "...", "agent" => "..." } }
+# New format: { "wi-abc123" => { "id" => "wi-...", "branch" => "...", "worktree" => "...",
+#   "project" => "...", "agent" => "...", "sources" => { "fizzy" => { ... } } } }
+def migrate_work_item_map(raw)
+  return raw if raw.empty?
+
+  # Detect: if any entry has a "sources" key, it's already new format (or mixed)
+  # If none have "sources", it's entirely old format
+  needs_migration = raw.values.any? { |v| v.is_a?(Hash) && !v.key?("sources") }
+  return raw unless needs_migration
+
+  migrated = {}
+  raw.each do |key, entry|
+    next unless entry.is_a?(Hash)
+
+    if entry.key?("sources")
+      # Already new format
+      migrated[key] = entry
+    else
+      # Old format — migrate. Generate a work item ID from the branch or card number.
+      work_item_id = generate_work_item_id(branch: entry["branch"], card_number: entry["number"])
+      migrated[work_item_id] = {
+        "id" => work_item_id,
+        "branch" => entry["branch"],
+        "worktree" => entry["worktree"],
+        "project" => entry["project"],
+        "agent" => entry["agent"],
+        "sources" => {
+          "fizzy" => {
+            "card_internal_id" => key,
+            "card_number" => entry["number"]
+          }
+        }
+      }
+      # Preserve PR tracking if it exists
+      migrated[work_item_id]["sources"]["github"] = { "prs" => entry["prs"] } if entry["prs"]
+    end
+  end
+  migrated
+end
+
+# Generate a deterministic work item ID from available identifiers.
+# Priority: branch name (universal join key), then card number fallback.
+def generate_work_item_id(branch: nil, card_number: nil)
+  if branch
+    "wi-#{Digest::SHA256.hexdigest(branch)[0..7]}"
+  elsif card_number
+    "wi-card-#{card_number}"
+  else
+    "wi-#{SecureRandom.hex(4)}"
+  end
+end
+
+# Find a work item by its branch name. Returns [work_item_id, info] or nil.
+# This is the primary lookup method — branch is the universal join key.
+def find_work_item_by_branch(branch)
+  return nil unless branch
+
+  map = load_work_item_map
+  map.each do |work_item_id, info|
+    next unless info.is_a?(Hash) && info["branch"] == branch
+
+    return [work_item_id, info]
+  end
+  nil
+end
+
+# Find a work item by its ID. Returns the info hash or nil.
+def find_work_item_by_id(work_item_id)
+  return nil unless work_item_id
+
+  map = load_work_item_map
+  map[work_item_id]
+end
+
+# Find a work item by a Fizzy card internal ID (for backward compat with Fizzy plugin).
+# Returns [work_item_id, info] or nil.
+def find_work_item_by_card(card_internal_id)
+  return nil unless card_internal_id
+
+  map = load_work_item_map
+  map.each do |work_item_id, info|
+    next unless info.is_a?(Hash)
+
+    fizzy_source = info.dig("sources", "fizzy")
+    next unless fizzy_source && fizzy_source["card_internal_id"] == card_internal_id
+
+    return [work_item_id, info]
+  end
+  nil
+end
+
+# Register a new work item or update an existing one.
+# Returns the work item ID.
+def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source: nil, source_data: {})
+  map = load_work_item_map
+
+  # Check if a work item already exists for this branch
+  existing_id = nil
+  map.each do |wid, info|
+    if info.is_a?(Hash) && info["branch"] == branch
+      existing_id = wid
+      break
+    end
+  end
+
+  work_item_id = existing_id || generate_work_item_id(branch: branch)
+
+  if existing_id
+    # Update existing entry — merge in new source, update worktree/agent if provided
+    map[work_item_id]["worktree"] = worktree if worktree
+    map[work_item_id]["agent"] = agent if agent
+    map[work_item_id]["sources"] ||= {}
+    map[work_item_id]["sources"][source] = source_data if source
+  else
+    # Create new entry
+    map[work_item_id] = {
+      "id" => work_item_id,
+      "branch" => branch,
+      "worktree" => worktree,
+      "project" => project,
+      "agent" => agent,
+      "sources" => source ? { source => source_data } : {}
+    }
+  end
+
+  save_work_item_map(map)
+  work_item_id
+end
+
+# Add or update a source on an existing work item.
+# Returns true if the work item was found and updated, false otherwise.
+def register_work_item_source(source:, source_data:, work_item_id: nil, branch: nil) # rubocop:disable Naming/PredicateMethod
+  map = load_work_item_map
+
+  # Find by ID or branch
+  target_id = work_item_id
+  unless target_id
+    map.each do |wid, info|
+      if info.is_a?(Hash) && info["branch"] == branch
+        target_id = wid
+        break
+      end
+    end
+  end
+
+  return false unless target_id && map[target_id]
+
+  map[target_id]["sources"] ||= {}
+  map[target_id]["sources"][source] = source_data
+  save_work_item_map(map)
+  true
+end
+
 def slugify(title, max_length: 40)
   title.downcase.gsub(/[^a-z0-9\s-]/, "").strip.gsub(/\s+/, "-").slice(0, max_length).chomp("-")
 end

data/lib/brainiac/version.rb

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

data/templates/hooks/pre-commit

@@ -0,0 +1,14 @@
+#!/bin/bash
+# Pre-commit hook: auto-run `bundle` when version.rb changes
+# This ensures Gemfile.lock stays in sync with gemspec version bumps.
+
+if git diff --cached --name-only | grep -q "version\.rb$"; then
+  echo "🔒 version.rb changed — running bundle to sync Gemfile.lock..."
+  bundle install --quiet
+  if [ $? -ne 0 ]; then
+    echo "❌ bundle install failed. Fix the issue and try again."
+    exit 1
+  fi
+  git add Gemfile.lock
+  echo "✅ Gemfile.lock updated and staged."
+fi

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Andy Davis
@@ -159,6 +159,7 @@ files:
 - templates/brainiac.json.example
 - templates/cli-providers/grok.json.example
 - templates/cli-providers/kiro.json.example
+- templates/hooks/pre-commit
 - templates/plugins.json.example
 - templates/roles/code-reviewer.md.example
 - templates/roles/general-engineer.md.example