@omnitype-code/cli 0.1.1 → 0.1.3

package/scripts/postinstall.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+'use strict';
+
+// Runs after `npm install -g @omnitype-code/cli`.
+// Silently installs sentinel hooks into any AI tools already on the machine,
+// then prints a short welcome guide so the user knows what just happened.
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ── Silent hook install + telemetry ───────────────────────────────────────
+// We call the compiled output directly so this script works without ts-node.
+let detectedTools = [];
+try {
+  const { installAllToolHooks } = require('../dist/core/ToolHookInstallers');
+  installAllToolHooks();
+} catch { /* dist not built yet (e.g. dev install) — skip */ }
+
+try {
+  const { detectInstalledTools } = require('../dist/core/ToolDetector');
+  detectedTools = detectInstalledTools();
+} catch {}
+
+// Fire-and-forget telemetry (only if user is already signed in from a prior install)
+try {
+  const { ApiClient } = require('../dist/core/ApiClient');
+  const api = new ApiClient();
+  if (detectedTools.length > 0) {
+    api.reportToolEnvironment(detectedTools.map(t => ({ id: t.id, name: t.name, hookSupport: t.hookSupport })));
+  }
+} catch {}
+
+// ── Welcome guide ──────────────────────────────────────────────────────────
+const dim   = s => `\x1b[2m${s}\x1b[0m`;
+const bold  = s => `\x1b[1m${s}\x1b[0m`;
+const cyan  = s => `\x1b[36m${s}\x1b[0m`;
+const green = s => `\x1b[32m${s}\x1b[0m`;
+const gray  = s => `\x1b[90m${s}\x1b[0m`;
+
+const box = (lines, title) => {
+  const width = Math.max(...lines.map(l => stripAnsi(l).length), stripAnsi(title).length) + 4;
+  const hr = '─'.repeat(width - 2);
+  const pad = s => {
+    const visible = stripAnsi(s).length;
+    return s + ' '.repeat(width - 2 - visible);
+  };
+  return [
+    `╭${hr}╮`,
+    `│ ${bold(cyan(title))}${' '.repeat(width - 2 - stripAnsi(title).length - 1)}│`,
+    `├${hr}┤`,
+    ...lines.map(l => `│ ${pad(l)}│`),
+    `╰${hr}╯`,
+  ].join('\n');
+};
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+const hookedTools   = detectedTools.filter(t => t.hookSupport === 'hooked').map(t => t.name);
+const unhookedTools = detectedTools.filter(t => t.hookSupport === 'no-hook').map(t => t.name);
+
+const lines = [
+  bold(green('✔ OmniType installed!')),
+  '',
+  bold('What it does:'),
+  `  Tracks which AI model wrote each line of code across`,
+  `  any editor — Claude Code, Cursor, Windsurf, Cline, etc.`,
+  '',
+  bold('Hooks installed for:'),
+  hookedTools.length
+    ? hookedTools.map(t => `  ${green('✔')} ${t}`).join('\n')
+    : `  ${gray('No hookable AI tools detected yet.')}`,
+  ...(unhookedTools.length ? [
+    '',
+    bold('Also detected (hook support coming):'),
+    unhookedTools.map(t => `  ${gray('○')} ${t}`).join('\n'),
+  ] : []),
+  '',
+  bold('Next steps:'),
+  `  ${cyan('omnitype login')}           Sign in to sync provenance to cloud`,
+  `  ${cyan('omnitype doctor')}          Check hook status for all tools`,
+  `  ${cyan('omnitype doctor --fix')}    Install/upgrade any missing hooks`,
+  `  ${cyan('omnitype status')}          Show active model in current workspace`,
+  '',
+  dim('Hooks give deterministic (100% accurate) model attribution.'),
+  dim('Without them attribution falls back to heuristics.'),
+];
+
+// Flatten nested arrays from the tools join
+const flat = lines.flatMap(l => typeof l === 'string' ? [l] : l.split('\n'));
+
+console.log('\n' + box(flat, 'OmniType — Code Provenance') + '\n');

package/src/core/ApiClient.ts

@@ -156,6 +156,21 @@ export class ApiClient {
     if (failed.length) throw new Error(`Push failed for chunks: ${failed.join(', ')}`);
   }
 
+  /**
+   * Fire-and-forget: reports which AI tools are detected on this machine.
+   * Used for market analysis — understanding which tools users have alongside OmniType.
+   * Never throws. Only sends if the user is signed in (respects opt-in via login).
+   */
+  reportToolEnvironment(tools: Array<{ id: string; name: string; hookSupport: string }>): void {
+    if (!this.isSignedIn) return;
+    const body = { tools, platform: process.platform, ts: Date.now() };
+    fetch(`${this.apiUrl}/telemetry/tools`, {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${this.config.token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }).catch(() => {}); // best-effort, never surface errors
+  }
+
   private async _postWithRetry(url: string, body: unknown, attempts: number, label: string): Promise<void> {
     const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
     for (let i = 0; i < attempts; i++) {

package/src/core/ModelDetector.ts

@@ -1,19 +1,8 @@
-/**
- * CLI ModelDetector — editor-agnostic model detection.
- *
- * Detection tiers:
- *   1. Universal sentinel   (~/.omnitype/active-model.json)
- *   2. Hooks sentinel file  (~/.claude/provenance-hook.json)
- *   3. Host IDE config      (Cursor/Windsurf/Zed settings.json — scanned generically)
- *   4. Config files         (per-tool config paths: .aider.conf.yml, etc.)
- *   5. Environment variables (CLAUDE_MODEL, AIDER_MODEL, etc.)
- *   6. Process detection    (lsof / ps — identifies the writing process)
- */
-
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
+import { scanTranscripts } from './TranscriptScanner';
 
 export interface ModelDetectionResult {
   model: string;
@@ -22,115 +11,141 @@ export interface ModelDetectionResult {
 }
 
 const UNKNOWN: ModelDetectionResult = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-const HOOKS_SENTINEL_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
-const UNIVERSAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
-const SENTINEL_MAX_AGE_MS = 10_000;
+const SENTINEL_MAX_AGE_MS = 30_000;
+const GLOBAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+
+function projectSentinelPath(cwd?: string): string {
+  return path.join(cwd ?? process.cwd(), '.omnitype', 'active-model.json');
+}
 
-const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[1234](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
+// Matches model identifier strings from all major providers.
+const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[134](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
 
-// Maps known CLI/IDE env vars to their tool
+// Each tool lists its OWN env vars only. Shared vars (OPENAI_MODEL) are NOT duplicated
+// across tools — the first matching entry wins, so ambiguous vars are assigned to
+// the most common owner (openai). Tools with a dedicated var (CODEX_MODEL) are checked
+// earlier so they can claim edits even when OPENAI_MODEL is also set.
 const ENV_VARS: Array<{ vars: string[]; tool: string }> = [
-  { vars: ['CLAUDE_MODEL', 'CLAUDE_CODE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
+  { vars: ['CLAUDE_CODE_MODEL', 'CLAUDE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
   { vars: ['AIDER_MODEL'],                                           tool: 'aider' },
+  { vars: ['CODEX_MODEL'],                                           tool: 'codex' },   // before generic OPENAI_MODEL
   { vars: ['OPENAI_MODEL', 'OPENAI_API_MODEL'],                     tool: 'openai' },
-  { vars: ['GEMINI_MODEL', 'GEMINI_API_KEY'],                       tool: 'gemini-cli' },
-  { vars: ['OLLAMA_MODEL'],                                         tool: 'ollama' },
-  { vars: ['COPILOT_MODEL'],                                        tool: 'copilot' },
-  { vars: ['LLM_MODEL'],                                            tool: 'openhands' },
-  { vars: ['TABBY_MODEL'],                                          tool: 'tabby' },
+  { vars: ['GEMINI_MODEL'],                                          tool: 'gemini-cli' },
+  { vars: ['OLLAMA_MODEL'],                                          tool: 'ollama' },
+  { vars: ['COPILOT_MODEL'],                                         tool: 'copilot' },
+  { vars: ['LLM_MODEL'],                                             tool: 'openhands' },
+  { vars: ['TABBY_MODEL'],                                           tool: 'tabby' },
 ];
 
-const KNOWN_FORKS = [
-  'Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'
-];
+const KNOWN_FORKS = ['Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'];
+const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+
+// Host IDE processes: always running — their presence does NOT mean they caused the edit.
+const HOST_IDE_PROCS = new Set(['cursor', 'windsurf', 'antigravity', 'pearai', 'void', 'trae', 'zed']);
 
-// lsof command-name → tool mapping
-const LSOF_CMD_MAP: Array<{ match: string; tool: string }> = [
-  { match: 'claude',    tool: 'claude-code' },
-  { match: 'aider',     tool: 'aider' },
-  { match: 'cursor',    tool: 'cursor' },
-  { match: 'windsurf',  tool: 'windsurf' },
-  { match: 'zed',       tool: 'zed' },
-  { match: 'pearai',    tool: 'pearai' },
-  { match: 'void',      tool: 'void' },
-  { match: 'tabby',     tool: 'tabby' },
-  { match: 'goose',     tool: 'goose' },
-  { match: 'node',      tool: 'unknown-cli' },
-  { match: 'python',    tool: 'unknown-cli' },
+const PROC_MAP: Array<{ match: string; tool: string }> = [
+  { match: 'claude',   tool: 'claude-code' },
+  { match: 'aider',    tool: 'aider' },
+  { match: 'goose',    tool: 'goose' },
+  { match: 'codex',    tool: 'codex' },
+  { match: 'tabby',    tool: 'tabby' },
 ];
 
 export class ModelDetector {
-  detect(changedFilePath?: string): ModelDetectionResult {
+  detect(changedFilePath?: string, cwd?: string): ModelDetectionResult {
     return (
-      this._fromUniversalSentinel() ??
-      this._fromHooksSentinel() ??
-      this._fromIdeConfigs() ??
+      this._sentinel(projectSentinelPath(cwd), changedFilePath) ??
+      this._sentinel(GLOBAL_SENTINEL_PATH, changedFilePath) ??
       this._fromEnv() ??
-      this._fromPsPatterns() ??
+      this._fromTranscripts(cwd) ??
+      this._fromIdeConfigs() ??
+      this._fromPs() ??
       (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
       UNKNOWN
     );
   }
 
-  private _fromUniversalSentinel(): ModelDetectionResult | undefined {
-    try {
-      const stat = fs.statSync(UNIVERSAL_SENTINEL_PATH);
-      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
-      const data = JSON.parse(fs.readFileSync(UNIVERSAL_SENTINEL_PATH, 'utf8'));
-      if (!data?.model || data.model === 'unknown') return undefined;
-      return { model: data.model, tool: data.tool ?? 'unknown-tool', confidence: 'deterministic' };
-    } catch { return undefined; }
+  private _fromTranscripts(cwd?: string): ModelDetectionResult | undefined {
+    const r = scanTranscripts(cwd);
+    if (!r) return undefined;
+    return { model: r.model, tool: r.tool, confidence: 'high' };
   }
 
-  private _fromHooksSentinel(): ModelDetectionResult | undefined {
+  private _sentinel(filePath: string, changedPath?: string): ModelDetectionResult | undefined {
     try {
-      const stat = fs.statSync(HOOKS_SENTINEL_PATH);
-      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
-      const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
-      if (!data?.model || data.model === 'unknown') return undefined;
-      return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+      const mtime = fs.statSync(filePath).mtimeMs;
+      const d = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (!d?.model || d.model === 'unknown') return undefined;
+
+      if (d.file && changedPath) {
+        // File-path gated: trust only if the sentinel targets this exact file.
+        // Use a generous TTL since path specificity eliminates cross-file contamination.
+        if (d.file !== changedPath) return undefined;
+        if (Date.now() - mtime > 120_000) return undefined; // 2 min max
+      } else {
+        // No path info: fall back to strict TTL to minimise false attribution.
+        if (Date.now() - mtime > SENTINEL_MAX_AGE_MS) return undefined;
+      }
+
+      if (!d?.model || d.model === 'unknown') return undefined;
+      return { model: d.model, tool: d.tool ?? 'unknown-tool', confidence: 'deterministic' };
     } catch { return undefined; }
   }
 
+  private _fromEnv(): ModelDetectionResult | undefined {
+    for (const { vars, tool } of ENV_VARS)
+      for (const v of vars) { const val = process.env[v]; if (val && MODEL_PATTERN.test(val)) return { model: val, tool, confidence: 'high' }; }
+    return undefined;
+  }
+
   private _fromIdeConfigs(): ModelDetectionResult | undefined {
     for (const appName of KNOWN_FORKS) {
       const scan = this._scanIdeSettings(appName);
-      if (scan) {
-        return { 
-          model: scan.model, 
-          tool: appName.toLowerCase(), 
-          confidence: scan.isAuto ? 'medium' : 'high' 
-        };
-      }
+      if (scan) return { model: scan.model, tool: appName.toLowerCase(), confidence: scan.isAuto ? 'medium' : 'high' };
     }
+    // Copilot: no hook API, but model is readable from VS Code / fork settings.json
+    const copilot = this._fromCopilotConfig();
+    if (copilot) return copilot;
     return undefined;
   }
 
-  private _fromEnv(): ModelDetectionResult | undefined {
-    for (const { vars, tool } of ENV_VARS) {
-      for (const v of vars) {
-        const val = process.env[v];
-        if (val && MODEL_PATTERN.test(val)) {
-          return { model: val, tool, confidence: 'high' };
-        }
+  private _fromCopilotConfig(): ModelDetectionResult | undefined {
+    const COPILOT_KEYS = [
+      'github.copilot.advanced.model',
+      'github.copilot.selectedModel',
+      'github.copilot.chat.models.default',
+      'github.copilot.chat.agent.model',
+    ];
+    // Check VS Code and every known fork's settings.json
+    const vscodePaths = (() => {
+      switch (process.platform) {
+        case 'darwin':  return [path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json')];
+        case 'win32':   return [path.join(process.env.APPDATA ?? '', 'Code', 'User', 'settings.json')];
+        default:        return [path.join(os.homedir(), '.config', 'Code', 'User', 'settings.json')];
       }
+    })();
+    for (const settingsPath of vscodePaths) {
+      try {
+        const flat = this._flatten(JSON.parse(fs.readFileSync(settingsPath, 'utf8')));
+        for (const key of COPILOT_KEYS) {
+          const val = flat[key];
+          if (typeof val === 'string' && val && MODEL_PATTERN.test(val))
+            return { model: val.toLowerCase(), tool: 'copilot', confidence: 'high' };
+        }
+      } catch {}
     }
     return undefined;
   }
 
-  private _fromPsPatterns(): ModelDetectionResult | undefined {
+  private _fromPs(): ModelDetectionResult | undefined {
     if (process.platform === 'win32') return undefined;
     try {
       const lines = execFileSync('ps', ['ax', '-o', 'args='], { timeout: 800, encoding: 'utf8' }).split('\n');
-      for (const line of lines) {
-        for (const entry of LSOF_CMD_MAP) {
-          if (line.toLowerCase().includes(entry.match)) {
-            // Fallback model name
-            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-          }
-        }
-      }
-    } catch { /* ps unavailable */ }
+      for (const line of lines)
+        for (const { match, tool } of PROC_MAP)
+          if (line.toLowerCase().includes(match) && !HOST_IDE_PROCS.has(tool))
+            return { model: `${tool}-default`, tool, confidence: 'low' };
+    } catch {}
     return undefined;
   }
 
@@ -141,57 +156,36 @@ export class ModelDetector {
       for (const line of out.split('\n')) {
         if (!line.startsWith('c')) continue;
         const cmd = line.slice(1).toLowerCase();
-        for (const entry of LSOF_CMD_MAP) {
-          if (cmd.includes(entry.match)) {
-            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
-          }
-        }
+        for (const { match, tool } of PROC_MAP)
+          if (cmd.includes(match) && !HOST_IDE_PROCS.has(tool))
+            return { model: `${tool}-default`, tool, confidence: 'low' };
       }
-    } catch { /* lsof unavailable */ }
+    } catch {}
     return undefined;
   }
 
   private _scanIdeSettings(appName: string): { model: string; isAuto: boolean } | undefined {
-    for (const p of this._getIdeSettingsPaths(appName)) {
+    for (const p of this._idePaths(appName)) {
       try {
-        const raw = fs.readFileSync(p, 'utf8');
-        const json = JSON.parse(raw);
-        const flat = this._flattenObject(json);
-        
-        const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+        const flat = this._flatten(JSON.parse(fs.readFileSync(p, 'utf8')));
         const candidates: Array<{ key: string; value: string }> = [];
-
         for (const [key, value] of Object.entries(flat)) {
-          if (typeof value !== 'string' || !value) continue;
-          if (!key.toLowerCase().includes('model')) continue;
-
-          if (AUTO_SENTINELS.has(value.toLowerCase())) {
-            candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
-            continue;
-          }
-
-          if (MODEL_PATTERN.test(value)) {
-            candidates.push({ key, value: value.toLowerCase() });
-          }
-        }
-
-        if (candidates.length > 0) {
-          const real = candidates.filter(c => !c.value.endsWith('-auto'));
-          const pick = real.length > 0
-            ? real.sort((a, b) => b.key.length - a.key.length)[0]
-            : candidates.sort((a, b) => b.key.length - a.key.length)[0];
-          return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+          if (typeof value !== 'string' || !key.toLowerCase().includes('model')) continue;
+          if (AUTO_SENTINELS.has(value.toLowerCase())) { candidates.push({ key, value: `${appName.toLowerCase()}-auto` }); continue; }
+          if (MODEL_PATTERN.test(value)) candidates.push({ key, value: value.toLowerCase() });
         }
-      } catch { /* absent */ }
+        if (!candidates.length) continue;
+        const real = candidates.filter(c => !c.value.endsWith('-auto'));
+        const pick = (real.length ? real : candidates).sort((a, b) => b.key.length - a.key.length)[0];
+        return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+      } catch {}
     }
     return undefined;
   }
 
-  private _getIdeSettingsPaths(appName: string): string[] {
-    const toolId = appName.toLowerCase().replace(/\s+/g, '-');
-    const dirCandidates = [...new Set([appName, toolId])];
-
-    return dirCandidates.map(dir => {
+  private _idePaths(appName: string): string[] {
+    const id = appName.toLowerCase().replace(/\s+/g, '-');
+    return [...new Set([appName, id])].map(dir => {
       switch (process.platform) {
         case 'darwin': return path.join(os.homedir(), 'Library', 'Application Support', dir, 'User', 'settings.json');
         case 'win32':  return path.join(process.env.APPDATA ?? '', dir, 'User', 'settings.json');
@@ -200,16 +194,14 @@ export class ModelDetector {
     });
   }
 
-  private _flattenObject(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
+  private _flatten(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
     if (depth > 5) return {};
     const out: Record<string, unknown> = {};
     for (const [k, v] of Object.entries(obj)) {
       const key = prefix ? `${prefix}.${k}` : k;
-      if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
-        Object.assign(out, this._flattenObject(v as Record<string, unknown>, key, depth + 1));
-      } else {
-        out[key] = v;
-      }
+      if (v !== null && typeof v === 'object' && !Array.isArray(v))
+        Object.assign(out, this._flatten(v as Record<string, unknown>, key, depth + 1));
+      else out[key] = v;
     }
     return out;
   }

package/src/core/ToolDetector.ts

@@ -0,0 +1,227 @@
+/**
+ * Detects every AI coding tool present on the machine, whether or not OmniType
+ * has a hook for it. Used by the doctor command and for market-analysis telemetry.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+
+/**
+ * hooked       — OmniType has a sentinel hook (deterministic attribution)
+ * config-only  — No hook API, but model is readable from config/extension (high confidence)
+ * no-hook      — Detected but no support yet
+ */
+export type HookSupport = 'hooked' | 'config-only' | 'no-hook';
+
+export interface KnownTool {
+  id: string;
+  name: string;
+  hookSupport: HookSupport;
+  /** Returns true if the tool appears to be installed on this machine. */
+  detect: () => boolean;
+}
+
+const HOME = os.homedir();
+
+function exists(...parts: string[]): boolean {
+  try { fs.accessSync(path.join(...parts)); return true; } catch { return false; }
+}
+
+function inPath(bin: string): boolean {
+  try { execFileSync('which', [bin], { timeout: 500, stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+function macApp(name: string): boolean {
+  if (process.platform !== 'darwin') return false;
+  return exists('/Applications', name) || exists(HOME, 'Applications', name);
+}
+
+export const KNOWN_TOOLS: KnownTool[] = [
+  // ── Tools with OmniType hooks ────────────────────────────────────────────
+  {
+    id: 'claude-code',
+    name: 'Claude Code',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.claude') || inPath('claude'),
+  },
+  {
+    id: 'cursor',
+    name: 'Cursor',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.cursor') || macApp('Cursor.app'),
+  },
+  {
+    id: 'windsurf',
+    name: 'Windsurf',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.codeium') || macApp('Windsurf.app'),
+  },
+  {
+    id: 'codex',
+    name: 'Codex CLI',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.codex') || inPath('codex'),
+  },
+  {
+    id: 'cline',
+    name: 'Cline',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, 'Documents', 'Cline', 'Hooks') || exists(HOME, 'Documents', 'Cline'),
+  },
+
+  {
+    id: 'gemini-cli',
+    name: 'Gemini CLI',
+    hookSupport: 'hooked',
+    detect: () => inPath('gemini') || exists(HOME, '.gemini'),
+  },
+  {
+    id: 'droid',
+    name: 'Droid (Factory)',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.factory'),
+  },
+  {
+    id: 'firebender',
+    name: 'Firebender',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.firebender'),
+  },
+  {
+    id: 'amp',
+    name: 'Amp',
+    hookSupport: 'hooked',
+    detect: () => {
+      const xdg = process.env.XDG_DATA_HOME ?? path.join(HOME, '.local', 'share');
+      return inPath('amp') || exists(xdg, 'amp') ||
+        (process.platform === 'win32' && exists(process.env.LOCALAPPDATA ?? '', 'amp'));
+    },
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.config', 'opencode') || inPath('opencode'),
+  },
+  {
+    id: 'pi',
+    name: 'Pi',
+    hookSupport: 'hooked',
+    detect: () => exists(HOME, '.pi'),
+  },
+
+  // ── Tools detected but no hook yet ──────────────────────────────────────
+  {
+    id: 'aider',
+    name: 'Aider',
+    hookSupport: 'no-hook',
+    detect: () => inPath('aider') || exists(HOME, '.aider.conf.yml') || exists(HOME, '.aider'),
+  },
+  {
+    id: 'continue',
+    name: 'Continue',
+    hookSupport: 'no-hook',
+    detect: () => exists(HOME, '.continue') || inPath('continue'),
+  },
+  {
+    id: 'antigravity',
+    name: 'Antigravity',
+    hookSupport: 'no-hook',
+    detect: () => macApp('Antigravity.app') || macApp('Google Antigravity.app'),
+  },
+  {
+    id: 'pearai',
+    name: 'PearAI',
+    hookSupport: 'no-hook',
+    detect: () => macApp('PearAI.app') || exists(HOME, '.pearai'),
+  },
+  {
+    id: 'void',
+    name: 'Void',
+    hookSupport: 'no-hook',
+    detect: () => macApp('Void.app') || exists(HOME, '.void'),
+  },
+  {
+    id: 'zed',
+    name: 'Zed',
+    hookSupport: 'no-hook',
+    detect: () =>
+      macApp('Zed.app') ||
+      (process.platform === 'linux' && (inPath('zed') || exists(HOME, '.config', 'zed'))),
+  },
+  {
+    id: 'roo-cline',
+    name: 'Roo Code',
+    hookSupport: 'no-hook',
+    detect: () => exists(HOME, '.roo') || exists(HOME, '.roo-cline'),
+  },
+  {
+    id: 'tabnine',
+    name: 'Tabnine',
+    hookSupport: 'no-hook',
+    detect: () => exists(HOME, '.tabnine') || exists(HOME, '.config', 'tabnine'),
+  },
+  {
+    id: 'supermaven',
+    name: 'Supermaven',
+    hookSupport: 'no-hook',
+    detect: () => exists(HOME, '.supermaven'),
+  },
+  {
+    id: 'codeium',
+    name: 'Codeium',
+    hookSupport: 'no-hook',
+    // .codeium overlaps with Windsurf — only count if Windsurf isn't the reason
+    detect: () => exists(HOME, '.codeium', 'codeium') || exists(HOME, '.codeium', 'config'),
+  },
+  {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    // Copilot supports PreToolUse/PostToolUse hooks at ~/.copilot/hooks/
+    hookSupport: 'hooked',
+    detect: () =>
+      exists(HOME, '.copilot') ||
+      exists(HOME, '.vscode') ||
+      exists(HOME, 'Library', 'Application Support', 'Code') ||
+      exists(HOME, '.config', 'github-copilot'),
+  },
+  {
+    id: 'trae',
+    name: 'Trae',
+    hookSupport: 'no-hook',
+    detect: () => macApp('Trae.app') || exists(HOME, '.trae'),
+  },
+  {
+    id: 'goose',
+    name: 'Goose',
+    hookSupport: 'no-hook',
+    detect: () => inPath('goose') || exists(HOME, '.config', 'goose'),
+  },
+  {
+    id: 'openai-codex-legacy',
+    name: 'OpenAI Codex (legacy)',
+    hookSupport: 'no-hook',
+    detect: () => !!process.env.OPENAI_API_KEY && !exists(HOME, '.codex'),
+  },
+];
+
+export interface DetectedTool {
+  tool: KnownTool;
+  detected: boolean;
+}
+
+/** Returns all known tools with a detected flag. */
+export function detectAllTools(): DetectedTool[] {
+  return KNOWN_TOOLS.map(tool => {
+    let detected = false;
+    try { detected = tool.detect(); } catch {}
+    return { tool, detected };
+  });
+}
+
+/** Returns only the tools that are actually installed. */
+export function detectInstalledTools(): KnownTool[] {
+  return detectAllTools().filter(r => r.detected).map(r => r.tool);
+}