kodelyth-ecc 1.2.0

package/dashboard/lib/agent-tracker.js

@@ -0,0 +1,366 @@
+// Kodelyth Lens — Agent Auto-Tracker
+// Detects which ECC agents were used from conversation messages
+// Works across Claude Code, Cursor, Windsurf, Codex session logs
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+export const ECC_AGENTS = [
+  // Kodelyth Exclusive
+  'kodelyth-advisor', 'debug-detective', 'ux-reviewer', 'api-guardian',
+  'pair-programmer', 'migration-guide',
+  // Code Review
+  'code-reviewer', 'typescript-reviewer', 'python-reviewer', 'go-reviewer',
+  'rust-reviewer', 'java-reviewer', 'kotlin-reviewer', 'cpp-reviewer',
+  'csharp-reviewer', 'flutter-reviewer',
+  // Build Fixers
+  'build-error-resolver', 'go-build-resolver', 'rust-build-resolver',
+  'java-build-resolver', 'kotlin-build-resolver', 'cpp-build-resolver',
+  'dart-build-resolver', 'pytorch-build-resolver',
+  // Planning
+  'planner', 'architect', 'code-architect', 'code-explorer', 'chief-of-staff',
+  // Security
+  'security-reviewer', 'healthcare-reviewer',
+  // Quality
+  'refactor-cleaner', 'code-simplifier', 'performance-optimizer',
+  'type-design-analyzer', 'silent-failure-hunter',
+  // Testing
+  'tdd-guide', 'e2e-runner', 'pr-test-analyzer',
+  // Documentation
+  'doc-updater', 'docs-lookup', 'comment-analyzer',
+  // Open Source
+  'opensource-forker', 'opensource-sanitizer', 'opensource-packager',
+  // Specialized
+  'seo-specialist', 'database-reviewer', 'loop-operator', 'harness-optimizer',
+  // GAN
+  'gan-planner', 'gan-generator', 'gan-evaluator',
+  // Meta
+  'claude-code-guide', 'conversation-analyzer',
+];
+
+// Agent category colors for dashboard
+export const AGENT_COLORS = {
+  'kodelyth-advisor':   '#7c3aed',
+  'debug-detective':    '#dc2626',
+  'ux-reviewer':        '#0891b2',
+  'api-guardian':       '#f59e0b',
+  'pair-programmer':    '#10b981',
+  'migration-guide':    '#8b5cf6',
+  'code-reviewer':      '#3b82f6',
+  'security-reviewer':  '#ef4444',
+  'tdd-guide':          '#06b6d4',
+  'performance-optimizer': '#f97316',
+  'planner':            '#6366f1',
+  'architect':          '#8b5cf6',
+};
+
+const DEFAULT_COLOR = '#475569';
+
+export function getAgentColor(name) {
+  return AGENT_COLORS[name] || DEFAULT_COLOR;
+}
+
+// ── Intent / Emotion Detection ────────────────────────────────────────────────
+// Maps user emotional state and task keywords → recommended ECC agents
+// This layer runs in ADDITION to explicit invocation patterns —
+// it infers agent usage from what the user actually needed, not just what they typed.
+const INTENT_MAP = [
+  // ── Stuck / Lost / Don't know where to start ─────────────────────────────
+  {
+    patterns: [
+      /i[' ]?m\s+(stuck|lost|confused|overwhelmed|not sure|unsure|clueless)/i,
+      /don[' ]?t\s+know\s+(where|how|what)\s+to\s+start/i,
+      /where\s+do\s+i\s+(even\s+)?start/i,
+      /help\s+me\s+figure\s+out/i,
+      /what\s+(should|do)\s+i\s+do/i,
+      /i\s+don[' ]?t\s+understand\s+this/i,
+      /not\s+sure\s+what\s+to\s+do\s+next/i,
+    ],
+    agents: ['kodelyth-advisor'],
+  },
+
+  // ── Bug / Error / Something broke ────────────────────────────────────────
+  {
+    patterns: [
+      /\b(bug|bugs|buggy)\b/i,
+      /\b(broken|broke|breaking)\b/i,
+      /\berror\b.*\b(can[' ]?t|cannot|don[' ]?t|wont|won[' ]?t)\s+fix/i,
+      /why\s+(is|does|isn[' ]?t|doesn[' ]?t)\s+this\s+(work|working|fail|failing)/i,
+      /\b(crash|crashed|crashing|exception|traceback|stack\s*trace)\b/i,
+      /i[' ]?ve\s+been\s+(trying|debugging|fighting)\s+this\s+(for|all)/i,
+      /can[' ]?t\s+figure\s+out\s+(what|why|where|how)/i,
+      /this\s+(code|thing|function|module|component)\s+(won[' ]?t|doesn[' ]?t)\s+work/i,
+      /something\s+is\s+(wrong|broken|off|weird)\s+with/i,
+      /\bnot\s+working\b/i,
+    ],
+    agents: ['debug-detective'],
+  },
+
+  // ── Build failure ─────────────────────────────────────────────────────────
+  {
+    patterns: [
+      /build\s+(fail|failed|failing|error|broke)/i,
+      /\bcompile\s+(error|fail|failed)\b/i,
+      /\btype\s+error\b/i,
+      /\bts\s*\(\d+\)\b/i,
+      /\bcargo\s+build\b/i,
+      /\bnpm\s+(run\s+build|build)\b.*\bfail/i,
+      /can[' ]?t\s+build/i,
+    ],
+    agents: ['build-error-resolver'],
+  },
+
+  // ── Security / Vulnerability ──────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(security|secure|insecure|vulnerability|vulnerabilities|vulnerable)\b/i,
+      /\b(sql\s+injection|xss|csrf|authentication|authorization|auth\s+bypass)\b/i,
+      /\b(hack|hacked|exposed|leaked|leak|breach|exploit)\b/i,
+      /is\s+this\s+(safe|secure|vulnerable)/i,
+      /\b(api\s+key|secret|credential|password)\s+(exposed|leaked|in\s+(code|git|repo))\b/i,
+    ],
+    agents: ['security-reviewer'],
+  },
+
+  // ── Performance / Slow / Bottleneck ──────────────────────────────────────
+  {
+    patterns: [
+      /\b(slow|sluggish|laggy|performance|performant|optimize|optimization)\b/i,
+      /\b(memory\s+(leak|usage|pressure)|high\s+cpu|high\s+memory)\b/i,
+      /\b(bottleneck|profiling|bundle\s+size|load\s+time|render\s+time)\b/i,
+      /why\s+is\s+this\s+(so\s+)?slow/i,
+      /make\s+this\s+(faster|more\s+efficient|quicker)/i,
+      /\b(n\+1|n\s*\+\s*1|query\s+optimization)\b/i,
+    ],
+    agents: ['performance-optimizer'],
+  },
+
+  // ── Planning / Architecture / Design ─────────────────────────────────────
+  {
+    patterns: [
+      /how\s+should\s+i\s+(structure|design|architect|build|implement)\s+this/i,
+      /\b(plan|planning|roadmap|approach|strategy)\b.*\b(feature|system|project|app)\b/i,
+      /\b(architecture|architectural|system\s+design)\b/i,
+      /where\s+should\s+(this|the\s+code|it)\s+go/i,
+      /best\s+(way|approach|practice)\s+to\s+(build|implement|design)/i,
+      /should\s+i\s+(use|create|add|build)\s+a/i,
+    ],
+    agents: ['planner', 'architect'],
+  },
+
+  // ── Code review / Quality ─────────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(review|code\s+review|review\s+this\s+code|lgtm|looks\s+good)\b/i,
+      /\b(clean\s+(up|code)|refactor|dead\s+code|unused|duplicate)\b/i,
+      /is\s+this\s+(code\s+)?(good|clean|correct|right|okay|ok)\??/i,
+      /anything\s+(wrong|bad|to\s+improve)\s+(with|in)\s+this/i,
+    ],
+    agents: ['code-reviewer'],
+  },
+
+  // ── Tests / Testing / Coverage ────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(test|tests|testing|unit\s+test|integration\s+test|e2e)\b/i,
+      /\b(coverage|tdd|test\s+driven|failing\s+test)\b/i,
+      /write\s+(a\s+)?test\s+for/i,
+      /how\s+do\s+i\s+test\s+this/i,
+    ],
+    agents: ['tdd-guide'],
+  },
+
+  // ── UI / UX / Frontend / Accessibility ───────────────────────────────────
+  {
+    patterns: [
+      /\b(ui|ux|user\s+(interface|experience)|frontend|front[- ]end)\b/i,
+      /\b(accessibility|a11y|wcag|screen\s+reader|aria)\b/i,
+      /\b(usability|interaction|click|hover|form|button|modal)\b/i,
+      /does\s+this\s+(look|feel|work)\s+(right|good|okay)\s+for\s+(users|mobile)/i,
+    ],
+    agents: ['ux-reviewer'],
+  },
+
+  // ── Documentation ─────────────────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(document|docs|documentation|readme|jsdoc|comment)\b/i,
+      /add\s+(docs|documentation|comments|jsdoc)/i,
+      /how\s+do\s+i\s+document/i,
+    ],
+    agents: ['doc-updater'],
+  },
+
+  // ── Database / SQL / Query ────────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(sql|database|db|query|migration|schema|index|postgres|mysql|supabase)\b/i,
+      /\b(slow\s+query|n\+1|missing\s+index|table\s+scan)\b/i,
+      /how\s+should\s+i\s+(model|structure|design)\s+(the\s+)?(database|schema|table)/i,
+    ],
+    agents: ['database-reviewer'],
+  },
+
+  // ── Open source / Release ─────────────────────────────────────────────────
+  {
+    patterns: [
+      /\b(open[\s-]?source|publish|release|public\s+repo|make\s+(it\s+)?public)\b/i,
+      /\b(sanitize|strip\s+secrets|remove\s+(credentials|api\s+keys))\b/i,
+    ],
+    agents: ['opensource-forker', 'opensource-sanitizer'],
+  },
+];
+
+/**
+ * Detect ECC agents from user intent/emotion — goes beyond explicit invocations.
+ * Maps what the user says they're experiencing → the agent that helps with that.
+ * @param {Array<{role, content, timestamp}>} messages
+ * @returns {Array<{agent, timestamp, role, source}>}
+ */
+export function detectAgentsByIntent(messages) {
+  const found = [];
+
+  for (const msg of messages) {
+    if (!msg.content) continue;
+    // Only scan user messages for intent signals
+    if (msg.role && msg.role !== 'user') continue;
+
+    const text = typeof msg.content === 'string'
+      ? msg.content
+      : JSON.stringify(msg.content);
+
+    for (const { patterns, agents } of INTENT_MAP) {
+      const matched = patterns.some(p => p.test(text));
+      if (!matched) continue;
+
+      for (const agent of agents) {
+        found.push({
+          agent,
+          timestamp: msg.timestamp || null,
+          role: 'user',
+          source: 'intent',
+        });
+      }
+    }
+  }
+
+  // Deduplicate by agent+timestamp
+  const seen = new Set();
+  return found.filter(f => {
+    const key = `${f.agent}|${f.timestamp}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// Patterns that indicate ECC agent invocation
+const INVOKE_PATTERNS = [
+  /\buse\s+([\w-]+)/gi,
+  /\brun\s+([\w-]+)\s+agent/gi,
+  /@([\w-]+)/g,
+  /invoke\s+([\w-]+)/gi,
+  /delegate\s+to\s+([\w-]+)/gi,
+  /ask\s+([\w-]+)\s+to/gi,
+  /launch\s+([\w-]+)/gi,
+];
+
+/**
+ * Detect ECC agent names in a list of messages.
+ * Combines two detection layers:
+ *   1. Explicit invocation — "use debug-detective", "@code-reviewer", etc.
+ *   2. Intent / emotion   — "I'm stuck on this bug" → debug-detective
+ * @param {Array<{role, content, timestamp}>} messages
+ * @returns {Array<{agent, timestamp, role, source}>}
+ */
+export function detectAgentsInMessages(messages) {
+  const explicit = detectAgentsExplicit(messages);
+  const intent   = detectAgentsByIntent(messages);
+
+  // Merge — prefer explicit over intent for the same agent+timestamp
+  const seen = new Set();
+  const merged = [];
+
+  for (const f of [...explicit, ...intent]) {
+    const key = `${f.agent}|${f.timestamp}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(f);
+  }
+
+  return merged;
+}
+
+/**
+ * Detect ECC agents via explicit invocation patterns only.
+ * @param {Array<{role, content, timestamp}>} messages
+ * @returns {Array<{agent, timestamp, role, source}>}
+ */
+function detectAgentsExplicit(messages) {
+  const found = [];
+
+  for (const msg of messages) {
+    if (!msg.content) continue;
+    const text = typeof msg.content === 'string'
+      ? msg.content
+      : JSON.stringify(msg.content);
+
+    for (const pattern of INVOKE_PATTERNS) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(text)) !== null) {
+        const candidate = match[1].toLowerCase().trim();
+        if (ECC_AGENTS.includes(candidate)) {
+          found.push({
+            agent: candidate,
+            timestamp: msg.timestamp || null,
+            role: msg.role || 'user',
+            source: 'explicit',
+          });
+        }
+      }
+    }
+  }
+
+  // Deduplicate by agent+timestamp
+  const seen = new Set();
+  return found.filter(f => {
+    const key = `${f.agent}|${f.timestamp}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+/**
+ * Aggregate agent usage across all sessions into leaderboard
+ * @param {Array} sessions
+ * @returns {Array<AgentStat>}
+ */
+export function buildAgentLeaderboard(sessions) {
+  const map = {};
+
+  for (const session of sessions) {
+    for (const use of (session.agents || [])) {
+      const { agent } = use;
+      if (!map[agent]) {
+        map[agent] = {
+          name:       agent,
+          color:      getAgentColor(agent),
+          calls:      0,
+          sessionIds: new Set(),
+          platforms:  new Set(),
+          lastUsed:   null,
+        };
+      }
+      map[agent].calls++;
+      map[agent].sessionIds.add(session.id || session.timestamp || Math.random());
+      map[agent].platforms.add(session.platform || 'unknown');
+      if (!map[agent].lastUsed || (use.timestamp && use.timestamp > map[agent].lastUsed)) {
+        map[agent].lastUsed = use.timestamp;
+      }
+    }
+  }
+
+  return Object.values(map)
+    .map(a => ({ ...a, sessions: a.sessionIds.size, platforms: [...a.platforms] }))
+    .sort((a, b) => b.calls - a.calls);
+}

package/dashboard/lib/aggregator.js

@@ -0,0 +1,118 @@
+// Kodelyth Lens — Data Aggregator
+// Merges data from all platforms into unified stats
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+import { detectPlatforms } from './platform-detector.js';
+import { readClaudeData }       from './readers/claude-reader.js';
+import { readCursorData }       from './readers/cursor-reader.js';
+import { readWindsurfData }     from './readers/windsurf-reader.js';
+import { readCodexData }        from './readers/codex-reader.js';
+import { readOpenCodeData }     from './readers/opencode-reader.js';
+import { readAntigravityData }  from './readers/antigravity-reader.js';
+import { buildAgentLeaderboard } from './agent-tracker.js';
+import { buildDailyCosts, cacheSavings } from './cost-calculator.js';
+
+export async function aggregateAll() {
+  const platforms = detectPlatforms();
+
+  // Read all platforms in parallel, never crash if one fails
+  const [claude, cursor, windsurf, codex, opencode, antigravity] = await Promise.all([
+    platforms.claude.installed      ? readClaudeData(platforms.claude.dataDir).catch(() => ({ sessions: [] }))           : { sessions: [] },
+    platforms.cursor.installed      ? readCursorData(platforms.cursor.dataDir).catch(() => ({ sessions: [] }))           : { sessions: [] },
+    platforms.windsurf.installed    ? readWindsurfData(platforms.windsurf.dataDir).catch(() => ({ sessions: [] }))       : { sessions: [] },
+    platforms.codex.installed       ? readCodexData(platforms.codex.dataDir).catch(() => ({ sessions: [] }))             : { sessions: [] },
+    platforms.opencode.installed    ? readOpenCodeData(platforms.opencode.dataDir).catch(() => ({ sessions: [] }))       : { sessions: [] },
+    platforms.antigravity.installed ? readAntigravityData(platforms.antigravity.dataDir).catch(() => ({ sessions: [] })) : { sessions: [] },
+  ]);
+
+  const allSessions = [
+    ...claude.sessions,
+    ...cursor.sessions,
+    ...windsurf.sessions,
+    ...codex.sessions,
+    ...opencode.sessions,
+    ...antigravity.sessions,
+  ].sort((a, b) => (b.timestamp || '').localeCompare(a.timestamp || ''));
+
+  const today = new Date().toISOString().slice(0, 10);
+  // A session counts as "today" if it started today OR was last active today
+  // (long-running sessions that span multiple days still appear in today's stats)
+  const todaySessions = allSessions.filter(s => s.date === today || s.lastDate === today);
+
+  const totalCacheSaved = allSessions.reduce((n, s) => n + (s.cacheSaved || 0), 0);
+
+  const stats = {
+    today: {
+      sessions:   todaySessions.length,
+      tokens:     sumField(todaySessions, 'tokens.total'),
+      cost:       round(sumField(todaySessions, 'cost')),
+      agentCalls: sumField(todaySessions, 'agentCalls'),
+    },
+    allTime: {
+      sessions:    allSessions.length,
+      tokens:      sumField(allSessions, 'tokens.total'),
+      cost:        round(sumField(allSessions, 'cost')),
+      agentCalls:  sumField(allSessions, 'agentCalls'),
+      cacheSaved:  round(totalCacheSaved),
+      cacheHitRate: calcCacheHitRate(allSessions),
+    },
+  };
+
+  const platformStats = buildPlatformStats(allSessions, platforms);
+  const agents        = buildAgentLeaderboard(allSessions);
+  const dailyCosts    = buildDailyCosts(allSessions);
+
+  return {
+    stats,
+    agents,
+    sessions:  allSessions.slice(0, 100),
+    costs:     dailyCosts,
+    platforms: platformStats,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+function sumField(arr, field) {
+  return arr.reduce((n, s) => {
+    const parts = field.split('.');
+    let val = s;
+    for (const p of parts) val = val?.[p];
+    return n + (Number(val) || 0);
+  }, 0);
+}
+
+function round(n) { return Math.round(n * 10000) / 10000; }
+
+function calcCacheHitRate(sessions) {
+  const totalInput = sumField(sessions, 'tokens.input');
+  const totalRead  = sumField(sessions, 'tokens.cacheRead');
+  if (!totalInput && !totalRead) return 0;
+  return Math.round((totalRead / (totalInput + totalRead)) * 100);
+}
+
+function buildPlatformStats(sessions, platforms) {
+  const map = {};
+  for (const [key, info] of Object.entries(platforms)) {
+    map[key] = {
+      label:     info.label,
+      color:     info.color,
+      installed: info.installed,
+      sessions:  0,
+      tokens:    0,
+      cost:      0,
+      agents:    0,
+    };
+  }
+
+  for (const s of sessions) {
+    const p = map[s.platform];
+    if (!p) continue;
+    p.sessions++;
+    p.tokens += s.tokens?.total || 0;
+    p.cost   += s.cost          || 0;
+    p.agents += s.agentCalls    || 0;
+  }
+
+  for (const p of Object.values(map)) p.cost = round(p.cost);
+  return map;
+}

package/dashboard/lib/cost-calculator.js

@@ -0,0 +1,50 @@
+// Kodelyth Lens — Cost Calculator
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+const PRESETS = {
+  anthropic: { input: 3.00, output: 15.00, cacheRead: 0.30, cacheWrite: 3.75 },
+  bedrock:   { input: 5.00, output: 25.00, cacheRead: 0.50, cacheWrite: 6.25 },
+};
+
+export function getRates() {
+  const preset = process.env.PRICING_PRESET || 'anthropic';
+  const base = PRESETS[preset] || PRESETS.anthropic;
+  return {
+    input:      parseFloat(process.env.RATE_INPUT      || base.input),
+    output:     parseFloat(process.env.RATE_OUTPUT     || base.output),
+    cacheRead:  parseFloat(process.env.RATE_CACHE_READ || base.cacheRead),
+    cacheWrite: parseFloat(process.env.RATE_CACHE_WRITE|| base.cacheWrite),
+  };
+}
+
+export function tokensToCost(tokens) {
+  const r = getRates();
+  return (
+    ((tokens.input      || 0) / 1_000_000) * r.input  +
+    ((tokens.output     || 0) / 1_000_000) * r.output +
+    ((tokens.cacheRead  || 0) / 1_000_000) * r.cacheRead +
+    ((tokens.cacheWrite || 0) / 1_000_000) * r.cacheWrite
+  );
+}
+
+export function cacheSavings(tokens) {
+  const r = getRates();
+  // Savings = what cache reads would have cost as input tokens minus what they actually cost
+  const saved = ((tokens.cacheRead || 0) / 1_000_000) * (r.input - r.cacheRead);
+  return Math.max(0, saved);
+}
+
+export function buildDailyCosts(sessions) {
+  const byDay = {};
+  for (const s of sessions) {
+    const day = s.date;
+    if (!byDay[day]) byDay[day] = { date: day, cost: 0, tokens: 0, sessions: 0, agents: 0 };
+    byDay[day].cost     += s.cost     || 0;
+    byDay[day].tokens   += (s.tokens?.total || 0);
+    byDay[day].sessions += 1;
+    byDay[day].agents   += s.agentCalls || 0;
+  }
+  return Object.values(byDay)
+    .sort((a, b) => a.date.localeCompare(b.date))
+    .slice(-30); // last 30 days
+}

package/dashboard/lib/platform-detector.js

@@ -0,0 +1,89 @@
+// Kodelyth Lens — Platform Detector
+// Auto-detects installed AI coding platforms
+// Part of Kodelyth ECC — github.com/sifxprime/kodelyth-ecc
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const HOME = os.homedir();
+
+function exists(p) {
+  try { return fs.existsSync(p); } catch { return false; }
+}
+
+export function detectPlatforms() {
+  const appSupport = path.join(HOME, 'Library', 'Application Support'); // macOS
+  const appData    = path.join(HOME, 'AppData', 'Roaming');             // Windows
+
+  return {
+    claude: {
+      installed: exists(path.join(HOME, '.claude')),
+      dataDir: process.env.CLAUDE_DIR || path.join(HOME, '.claude'),
+      label: 'Claude Code',
+      color: '#f97316',
+    },
+    cursor: {
+      installed: exists(path.join(HOME, '.cursor')) ||
+                 exists(path.join(appSupport, 'Cursor')) ||
+                 exists(path.join(appData, 'Cursor')) ||
+                 exists(path.join(HOME, '.config', 'Cursor')),
+      dataDir: process.env.CURSOR_DIR ||
+               (exists(path.join(appSupport, 'Cursor'))
+                 ? path.join(appSupport, 'Cursor')
+                 : exists(path.join(HOME, '.config', 'Cursor'))
+                   ? path.join(HOME, '.config', 'Cursor')
+                   : path.join(HOME, '.cursor')),
+      label: 'Cursor',
+      color: '#3b82f6',
+    },
+    windsurf: {
+      installed: exists(path.join(HOME, '.codeium', 'windsurf')) ||
+                 exists(path.join(appSupport, 'Windsurf')) ||
+                 exists(path.join(appData, 'Windsurf')),
+      dataDir: process.env.WINDSURF_DIR ||
+               (exists(path.join(appSupport, 'Windsurf'))
+                 ? path.join(appSupport, 'Windsurf')
+                 : path.join(HOME, '.codeium', 'windsurf')),
+      label: 'Windsurf',
+      color: '#06b6d4',
+    },
+    codex: {
+      installed: exists(path.join(HOME, '.codex')),
+      dataDir: process.env.CODEX_DIR || path.join(HOME, '.codex'),
+      label: 'Codex CLI',
+      color: '#10b981',
+    },
+    antigravity: {
+      installed: exists(path.join(appSupport, 'Antigravity')) ||
+                 exists(path.join(appData, 'Antigravity')) ||
+                 exists(path.join(HOME, '.antigravity')) ||
+                 exists(path.join(process.cwd(), '.agent')),
+      dataDir: process.env.ANTIGRAVITY_DIR ||
+               (exists(path.join(appSupport, 'Antigravity'))
+                 ? path.join(appSupport, 'Antigravity')
+                 : exists(path.join(appData, 'Antigravity'))
+                   ? path.join(appData, 'Antigravity')
+                   : path.join(HOME, '.antigravity')),
+      label: 'Antigravity',
+      color: '#7c3aed',
+    },
+    opencode: {
+      installed: exists(path.join(HOME, '.opencode')) ||
+                 exists(path.join(HOME, '.config', 'opencode')) ||
+                 exists(path.join(appSupport, 'opencode')) ||
+                 exists(path.join(appData, 'opencode')) ||
+                 exists(path.join(process.cwd(), '.opencode')),
+      dataDir: process.env.OPENCODE_DIR ||
+               (exists(path.join(HOME, '.opencode'))
+                 ? path.join(HOME, '.opencode')
+                 : exists(path.join(HOME, '.config', 'opencode'))
+                   ? path.join(HOME, '.config', 'opencode')
+                   : exists(path.join(appSupport, 'opencode'))
+                     ? path.join(appSupport, 'opencode')
+                     : path.join(process.cwd(), '.opencode')),
+      label: 'OpenCode',
+      color: '#f43f5e',
+    },
+  };
+}