@omnitype-code/cli 0.1.1 → 0.1.3

package/src/core/ToolHookInstallers.ts

@@ -0,0 +1,580 @@
+/**
+ * Auto-installs OmniType model-detection hooks into AI tools that support
+ * a preToolUse/postToolUse hook system.
+ *
+ * Hooks write {model, tool, ts, file} to <project_root>/.omnitype/active-model.json.
+ * The project root is process.cwd() at hook invocation time — this isolates every
+ * workspace so concurrent sessions in different windows never bleed into each other.
+ * Falls back to ~/.omnitype/ if cwd is outside any workspace.
+ *
+ * Each installer is idempotent — safe to call on every startup.
+ * Fails silently so it never breaks the CLI for the user.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export const GLOBAL_OMNITYPE_DIR = path.join(os.homedir(), '.omnitype');
+
+// Version token embedded in every hook command.
+// Bump whenever hook logic changes so stale installs are replaced automatically.
+export const HOOK_VERSION = 'omnitype-hook-v4';
+
+// Shared sentinel-write snippet: resolves dir from process.cwd(), falls back to ~/.omnitype/.
+// `modelExpr` is a JS expression that evaluates to the model string (already extracted).
+// `tool` is the literal tool name string.
+const WRITE_SENTINEL = (tool: string) =>
+  `const fs=require('fs'),p=require('path'),os=require('os');` +
+  `const dir=p.join(process.cwd(),'.omnitype');` +
+  `const fbDir=p.join(os.homedir(),'.omnitype');` +
+  `fs.mkdirSync(dir,{recursive:true});` +
+  `fs.mkdirSync(fbDir,{recursive:true});` +
+  `const payload=JSON.stringify(Object.assign({model:m,tool:'${tool}',ts:Date.now()},file&&{file}));` +
+  `fs.writeFileSync(p.join(dir,'active-model.json'),payload);` +
+  `fs.writeFileSync(p.join(fbDir,'active-model.json'),payload);`;
+
+// Generic hook: reads model from stdin JSON, writes sentinel to project root + global fallback.
+function buildHookCommand(tool: string, modelField: string): string {
+  return (
+    `node -e "/*${HOOK_VERSION}*/let b='';process.stdin.on('data',c=>b+=c);` +
+    `process.stdin.on('end',()=>{` +
+    `try{const j=JSON.parse(b);` +
+    `let m=j['${modelField}']||j.model;` +
+    `if(!m)return;` +
+    `let file;try{file=j?.tool_input?.path||j?.tool_input?.file_path||j?.toolInput?.path;}catch{}` +
+    WRITE_SENTINEL(tool) +
+    `}catch{}})"`
+  );
+}
+
+// Claude Code hook: reads model from stdin first, then env, then settings.json.
+const CLAUDE_HOOK_CMD =
+  `node -e "/*${HOOK_VERSION}*/let b='';process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{` +
+  `try{` +
+  `let m,file;` +
+  `try{const j=JSON.parse(b);m=j.model;file=j?.tool_input?.path||j?.tool_input?.file_path||j?.toolInput?.path;}catch{}` +
+  `if(!m)m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL;` +
+  `if(!m){try{const _fs=require('fs'),_p=require('path'),_os=require('os');` +
+  `const s=JSON.parse(_fs.readFileSync(_p.join(_os.homedir(),'.claude','settings.json'),'utf8'));` +
+  `m=s.model||s.defaultModel;}catch{}}` +
+  `if(!m)return;` +
+  WRITE_SENTINEL('claude-code') +
+  `}catch{}})"`;
+function readJson(filePath: string): Record<string, any> {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return {}; }
+}
+
+function writeJsonAtomic(filePath: string, data: unknown): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = filePath + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
+  fs.renameSync(tmp, filePath);
+}
+
+/** True if a hook command string belongs to us (any version). */
+function isOurs(cmd: string): boolean { return cmd.includes('.omnitype'); }
+
+/** True if a hook command belongs to us AND is current (no upgrade needed). */
+function isCurrent(cmd: string): boolean { return cmd.includes(HOOK_VERSION); }
+
+/** Remove stale omnitype entries from an array of hook objects (any shape). */
+function purgeStale(arr: any[], cmdExtract: (h: any) => string | undefined): any[] {
+  return arr.filter(h => {
+    const cmd = cmdExtract(h) ?? '';
+    return !(isOurs(cmd) && !isCurrent(cmd));
+  });
+}
+
+// ── Claude Code ───────────────────────────────────────────────────────────────
+
+const CLAUDE_DIR      = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_HOOK_ENTRY = {
+  matcher: 'Write|Edit|MultiEdit|NotebookEdit',
+  hooks: [{ type: 'command', command: CLAUDE_HOOK_CMD }],
+};
+
+function installClaudeHooks(): void {
+  if (!fs.existsSync(CLAUDE_DIR)) return;
+  const s = readJson(CLAUDE_SETTINGS);
+  if (!s.hooks) s.hooks = {};
+  if (!Array.isArray(s.hooks.PreToolUse)) s.hooks.PreToolUse = [];
+  // Remove stale versions, then skip if current version already present.
+  s.hooks.PreToolUse = purgeStale(s.hooks.PreToolUse, h => h?.hooks?.[0]?.command);
+  if ((s.hooks.PreToolUse as any[]).some((h: any) => isCurrent(h?.hooks?.[0]?.command ?? ''))) return;
+  s.hooks.PreToolUse.push(CLAUDE_HOOK_ENTRY);
+  writeJsonAtomic(CLAUDE_SETTINGS, s);
+}
+
+// ── Cursor ────────────────────────────────────────────────────────────────────
+
+const CURSOR_HOOKS_PATH = path.join(os.homedir(), '.cursor', 'hooks.json');
+const CURSOR_CMD = buildHookCommand('cursor', 'model');
+
+function installCursorHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.cursor'))) return;
+  const settings = readJson(CURSOR_HOOKS_PATH);
+  if (!settings.hooks) settings.hooks = {};
+  let changed = false;
+  for (const event of ['preToolUse', 'postToolUse']) {
+    if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+    settings.hooks[event] = purgeStale(settings.hooks[event], h => h?.command);
+    if (!(settings.hooks[event] as any[]).some((h: any) => isCurrent(h?.command ?? ''))) {
+      settings.hooks[event].push({ command: CURSOR_CMD }); changed = true;
+    }
+  }
+  if (!settings.version) settings.version = 1;
+  if (changed) writeJsonAtomic(CURSOR_HOOKS_PATH, settings);
+}
+
+// ── Windsurf ──────────────────────────────────────────────────────────────────
+
+const WINDSURF_HOOK_PATHS = [
+  path.join(os.homedir(), '.codeium', 'windsurf', 'hooks.json'),
+  path.join(os.homedir(), '.codeium', 'hooks.json'),
+];
+const WINDSURF_EVENTS = ['pre_write_code', 'post_write_code', 'pre_run_command', 'post_run_command'];
+const WINDSURF_CMD = buildHookCommand('windsurf', 'model_name');
+
+function installWindsurfHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.codeium'))) return;
+  for (const hookPath of WINDSURF_HOOK_PATHS) {
+    if (!fs.existsSync(hookPath) && !fs.existsSync(path.dirname(hookPath))) continue;
+    const settings = readJson(hookPath);
+    if (!settings.hooks) settings.hooks = {};
+    let changed = false;
+    for (const event of WINDSURF_EVENTS) {
+      if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+      settings.hooks[event] = purgeStale(settings.hooks[event], h => h?.command);
+      if (!(settings.hooks[event] as any[]).some((h: any) => isCurrent(h?.command ?? ''))) {
+        settings.hooks[event].push({ command: WINDSURF_CMD }); changed = true;
+      }
+    }
+    if (changed) writeJsonAtomic(hookPath, settings);
+  }
+}
+
+// ── Codex ─────────────────────────────────────────────────────────────────────
+
+const CODEX_HOOKS_PATH = path.join(os.homedir(), '.codex', 'hooks.json');
+const CODEX_CMD = buildHookCommand('codex', 'model');
+
+function installCodexHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.codex'))) return;
+  const settings = readJson(CODEX_HOOKS_PATH);
+  let changed = false;
+  for (const event of ['PreToolUse', 'PostToolUse']) {
+    if (!Array.isArray(settings[event])) settings[event] = [];
+    settings[event] = purgeStale(settings[event], h => h?.command);
+    if (!(settings[event] as any[]).some((h: any) => isCurrent(h?.command ?? ''))) {
+      settings[event].push({ type: 'command', command: CODEX_CMD }); changed = true;
+    }
+  }
+  if (changed) writeJsonAtomic(CODEX_HOOKS_PATH, settings);
+}
+
+// ── Cline ─────────────────────────────────────────────────────────────────────
+// Cline looks for executable scripts in ~/Documents/Cline/Hooks/ named after
+// hook events. We drop a PreToolUse script that reads stdin JSON and writes
+// the sentinel only for file-modifying tools, including the target file path.
+
+const CLINE_HOOKS_DIR = path.join(os.homedir(), 'Documents', 'Cline', 'Hooks');
+const CLINE_HOOK_SCRIPT = `#!/usr/bin/env node
+// ${HOOK_VERSION}
+const FILE_WRITE_TOOLS = new Set(['write_to_file','apply_diff','insert_content','search_and_replace']);
+let buf = '';
+process.stdin.on('data', c => buf += c);
+process.stdin.on('end', () => {
+  try {
+    const j = JSON.parse(buf);
+    if (!FILE_WRITE_TOOLS.has(j.toolName)) return;
+    const m = j.model || j.preToolUse?.model || '';
+    const file = j.toolInput?.path || j.toolInput?.file_path || j.tool_input?.path || undefined;
+    const fs = require('fs'), p = require('path'), os = require('os');
+    const dir = p.join(process.cwd(), '.omnitype');
+    const fbDir = p.join(os.homedir(), '.omnitype');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.mkdirSync(fbDir, { recursive: true });
+    const payload = JSON.stringify(Object.assign({ model: m, tool: 'cline', ts: Date.now() }, file && { file }));
+    fs.writeFileSync(p.join(dir, 'active-model.json'), payload);
+    fs.writeFileSync(p.join(fbDir, 'active-model.json'), payload);
+  } catch {}
+});
+`;
+
+function installClineHooks(): void {
+  if (!fs.existsSync(CLINE_HOOKS_DIR)) return;
+  const scriptPath = path.join(CLINE_HOOKS_DIR, 'PreToolUse');
+  let existing = '';
+  try { existing = fs.readFileSync(scriptPath, 'utf8'); } catch {}
+  if (existing.includes(HOOK_VERSION)) return; // already current
+  // Write (or overwrite stale version)
+  fs.writeFileSync(scriptPath, CLINE_HOOK_SCRIPT, 'utf8');
+  fs.chmodSync(scriptPath, 0o755);
+}
+
+// ── Gemini CLI ────────────────────────────────────────────────────────────────
+// ~/.gemini/settings.json — BeforeTool / AfterTool with nested hooks array
+
+const GEMINI_SETTINGS_PATH = path.join(os.homedir(), '.gemini', 'settings.json');
+const GEMINI_CMD = buildHookCommand('gemini-cli', 'model');
+const GEMINI_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: GEMINI_CMD }] };
+
+function installGeminiHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.gemini'))) return;
+  const s = readJson(GEMINI_SETTINGS_PATH);
+  let changed = false;
+  for (const ev of ['BeforeTool', 'AfterTool']) {
+    if (!Array.isArray(s[ev])) s[ev] = [];
+    s[ev] = purgeStale(s[ev], h => h?.hooks?.[0]?.command);
+    if (!(s[ev] as any[]).some((h: any) => isCurrent(h?.hooks?.[0]?.command ?? ''))) {
+      s[ev].push(GEMINI_HOOK_ENTRY); changed = true;
+    }
+  }
+  if (changed) writeJsonAtomic(GEMINI_SETTINGS_PATH, s);
+}
+
+// ── Droid (Factory) ───────────────────────────────────────────────────────────
+// ~/.factory/settings.json — PreToolUse with nested hooks array
+
+const DROID_SETTINGS_PATH = path.join(os.homedir(), '.factory', 'settings.json');
+const DROID_CMD = buildHookCommand('droid', 'model');
+const DROID_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: DROID_CMD }] };
+
+function installDroidHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.factory'))) return;
+  const s = readJson(DROID_SETTINGS_PATH);
+  if (!Array.isArray(s.PreToolUse)) s.PreToolUse = [];
+  s.PreToolUse = purgeStale(s.PreToolUse, h => h?.hooks?.[0]?.command);
+  if ((s.PreToolUse as any[]).some((h: any) => isCurrent(h?.hooks?.[0]?.command ?? ''))) return;
+  s.PreToolUse.push(DROID_HOOK_ENTRY);
+  writeJsonAtomic(DROID_SETTINGS_PATH, s);
+}
+
+// ── Firebender ────────────────────────────────────────────────────────────────
+// ~/.firebender/hooks.json — preToolUse / postToolUse flat command arrays
+
+const FIREBENDER_HOOKS_PATH = path.join(os.homedir(), '.firebender', 'hooks.json');
+const FIREBENDER_CMD = buildHookCommand('firebender', 'model');
+
+function installFirebenderHooks(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.firebender'))) return;
+  const s = readJson(FIREBENDER_HOOKS_PATH);
+  let changed = false;
+  for (const ev of ['preToolUse', 'postToolUse']) {
+    if (!Array.isArray(s[ev])) s[ev] = [];
+    s[ev] = purgeStale(s[ev], h => h?.command);
+    if (!(s[ev] as any[]).some((h: any) => isCurrent(h?.command ?? ''))) {
+      s[ev].push({ command: FIREBENDER_CMD }); changed = true;
+    }
+  }
+  if (changed) writeJsonAtomic(FIREBENDER_HOOKS_PATH, s);
+}
+
+// ── Amp ───────────────────────────────────────────────────────────────────────
+// Amp uses a TypeScript plugin (not hooks.json). Drop a .ts file to
+// ~/.config/amp/plugins/omnitype.ts
+
+const AMP_PLUGINS_DIR  = path.join(os.homedir(), '.config', 'amp', 'plugins');
+const AMP_PLUGIN_PATH  = path.join(AMP_PLUGINS_DIR, 'omnitype.ts');
+const AMP_PLUGIN_SRC = `// @i-know-the-amp-plugin-api-is-wip-and-very-experimental-right-now
+// ${HOOK_VERSION}
+import * as amp from 'amp';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+function writeSentinel(model: string, file?: string) {
+  const payload = JSON.stringify(Object.assign({ model, tool: 'amp', ts: Date.now() }, file && { file }));
+  for (const dir of [path.join(process.cwd(), '.omnitype'), path.join(os.homedir(), '.omnitype')]) {
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, 'active-model.json'), payload); } catch {}
+  }
+}
+
+amp.on('tool.call', (event: any) => {
+  try {
+    const model = event?.model ?? event?.session?.model;
+    if (!model) return;
+    writeSentinel(model, event?.input?.path ?? event?.input?.file_path);
+  } catch {}
+});
+`;
+
+function installAmpPlugin(): void {
+  const ampDataDir = process.platform === 'win32'
+    ? path.join(process.env.LOCALAPPDATA ?? os.homedir(), 'amp')
+    : path.join(process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share'), 'amp');
+  if (!fs.existsSync(ampDataDir) && !fs.existsSync(AMP_PLUGINS_DIR)) return;
+  let existing = '';
+  try { existing = fs.readFileSync(AMP_PLUGIN_PATH, 'utf8'); } catch {}
+  if (existing.includes(HOOK_VERSION)) return;
+  fs.mkdirSync(AMP_PLUGINS_DIR, { recursive: true });
+  fs.writeFileSync(AMP_PLUGIN_PATH, AMP_PLUGIN_SRC, 'utf8');
+}
+
+// ── OpenCode ──────────────────────────────────────────────────────────────────
+// TS plugin at ~/.config/opencode/plugins/omnitype.ts
+
+const OPENCODE_PLUGINS_DIR = path.join(os.homedir(), '.config', 'opencode', 'plugins');
+const OPENCODE_PLUGIN_PATH = path.join(OPENCODE_PLUGINS_DIR, 'omnitype.ts');
+const OPENCODE_PLUGIN_SRC = `// ${HOOK_VERSION}
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+function writeSentinel(model: string, file?: string) {
+  const payload = JSON.stringify(Object.assign({ model, tool: 'opencode', ts: Date.now() }, file && { file }));
+  for (const dir of [path.join(process.cwd(), '.omnitype'), path.join(os.homedir(), '.omnitype')]) {
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, 'active-model.json'), payload); } catch {}
+  }
+}
+
+export function activate(ctx: any) {
+  ctx.on('tool.execute.before', (event: any) => {
+    try {
+      const model = event?.model ?? event?.session?.model;
+      if (!model) return;
+      writeSentinel(model, event?.input?.path ?? event?.input?.file_path);
+    } catch {}
+  });
+}
+`;
+
+function installOpenCodePlugin(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.config', 'opencode'))) return;
+  let existing = '';
+  try { existing = fs.readFileSync(OPENCODE_PLUGIN_PATH, 'utf8'); } catch {}
+  if (existing.includes(HOOK_VERSION)) return;
+  fs.mkdirSync(OPENCODE_PLUGINS_DIR, { recursive: true });
+  fs.writeFileSync(OPENCODE_PLUGIN_PATH, OPENCODE_PLUGIN_SRC, 'utf8');
+}
+
+// ── Pi ────────────────────────────────────────────────────────────────────────
+// TS extension at ~/.pi/agent/extensions/omnitype.ts
+
+const PI_EXTENSIONS_DIR = path.join(os.homedir(), '.pi', 'agent', 'extensions');
+const PI_PLUGIN_PATH    = path.join(PI_EXTENSIONS_DIR, 'omnitype.ts');
+const PI_PLUGIN_SRC = `// ${HOOK_VERSION}
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+function writeSentinel(model: string, file?: string) {
+  const payload = JSON.stringify(Object.assign({ model, tool: 'pi', ts: Date.now() }, file && { file }));
+  for (const dir of [path.join(process.cwd(), '.omnitype'), path.join(os.homedir(), '.omnitype')]) {
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, 'active-model.json'), payload); } catch {}
+  }
+}
+
+export default {
+  name: 'omnitype',
+  onToolCall(event: any) {
+    try {
+      const model = event?.model ?? event?.agent?.model;
+      if (!model) return;
+      writeSentinel(model, event?.input?.path ?? event?.input?.file_path);
+    } catch {}
+  },
+};
+`;
+
+function installPiPlugin(): void {
+  if (!fs.existsSync(path.join(os.homedir(), '.pi'))) return;
+  let existing = '';
+  try { existing = fs.readFileSync(PI_PLUGIN_PATH, 'utf8'); } catch {}
+  if (existing.includes(HOOK_VERSION)) return;
+  fs.mkdirSync(PI_EXTENSIONS_DIR, { recursive: true });
+  fs.writeFileSync(PI_PLUGIN_PATH, PI_PLUGIN_SRC, 'utf8');
+}
+
+// ── GitHub Copilot ────────────────────────────────────────────────────────────
+// Copilot supports a hooks file at ~/.copilot/hooks/omnitype.json with
+// PreToolUse / PostToolUse arrays — same shape as Claude Code.
+
+const COPILOT_HOOKS_PATH = path.join(os.homedir(), '.copilot', 'hooks', 'omnitype.json');
+const COPILOT_CMD = buildHookCommand('copilot', 'model');
+
+function installCopilotHooks(): void {
+  // Require either ~/.copilot or ~/.vscode or VS Code settings to exist
+  const hasVscode = fs.existsSync(path.join(os.homedir(), '.vscode')) ||
+    fs.existsSync(path.join(os.homedir(), 'Library', 'Application Support', 'Code'));
+  const hasCopilotDir = fs.existsSync(path.join(os.homedir(), '.copilot'));
+  if (!hasVscode && !hasCopilotDir) return;
+
+  const s = readJson(COPILOT_HOOKS_PATH);
+  if (!s.hooks) s.hooks = {};
+  let changed = false;
+  for (const ev of ['PreToolUse', 'PostToolUse']) {
+    if (!Array.isArray(s.hooks[ev])) s.hooks[ev] = [];
+    s.hooks[ev] = purgeStale(s.hooks[ev], h => h?.command);
+    if (!(s.hooks[ev] as any[]).some((h: any) => isCurrent(h?.command ?? ''))) {
+      s.hooks[ev].push({ type: 'command', command: COPILOT_CMD }); changed = true;
+    }
+  }
+  if (changed) writeJsonAtomic(COPILOT_HOOKS_PATH, s);
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+export function installAllToolHooks(): void {
+  try { installClaudeHooks(); } catch {}
+  try { installCursorHooks(); } catch {}
+  try { installWindsurfHooks(); } catch {}
+  try { installCodexHooks(); } catch {}
+  try { installClineHooks(); } catch {}
+  try { installCopilotHooks(); } catch {}
+  try { installGeminiHooks(); } catch {}
+  try { installDroidHooks(); } catch {}
+  try { installFirebenderHooks(); } catch {}
+  try { installAmpPlugin(); } catch {}
+  try { installOpenCodePlugin(); } catch {}
+  try { installPiPlugin(); } catch {}
+}
+
+export type HookStatus = 'installed' | 'stale' | 'not-installed' | 'tool-absent';
+
+export interface ToolHookStatus {
+  tool: string;
+  status: HookStatus;
+}
+
+export function checkHookStatus(): ToolHookStatus[] {
+  const results: ToolHookStatus[] = [];
+
+  // Claude Code
+  if (!fs.existsSync(CLAUDE_DIR)) {
+    results.push({ tool: 'claude-code', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(CLAUDE_SETTINGS)?.hooks?.PreToolUse ?? [];
+    const cmd = (h: any) => h?.hooks?.[0]?.command ?? '';
+    if (hooks.some(h => isCurrent(cmd(h))))        results.push({ tool: 'claude-code', status: 'installed' });
+    else if (hooks.some(h => isOurs(cmd(h))))       results.push({ tool: 'claude-code', status: 'stale' });
+    else                                             results.push({ tool: 'claude-code', status: 'not-installed' });
+  }
+
+  // Cursor
+  if (!fs.existsSync(path.join(os.homedir(), '.cursor'))) {
+    results.push({ tool: 'cursor', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(CURSOR_HOOKS_PATH)?.hooks?.preToolUse ?? [];
+    if (hooks.some(h => isCurrent(h?.command ?? '')))  results.push({ tool: 'cursor', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.command ?? ''))) results.push({ tool: 'cursor', status: 'stale' });
+    else                                                results.push({ tool: 'cursor', status: 'not-installed' });
+  }
+
+  // Windsurf
+  if (!fs.existsSync(path.join(os.homedir(), '.codeium'))) {
+    results.push({ tool: 'windsurf', status: 'tool-absent' });
+  } else {
+    let status: HookStatus = 'not-installed';
+    for (const hp of WINDSURF_HOOK_PATHS) {
+      const hooks: any[] = readJson(hp)?.hooks?.pre_write_code ?? [];
+      if (hooks.some(h => isCurrent(h?.command ?? ''))) { status = 'installed'; break; }
+      if (hooks.some(h => isOurs(h?.command ?? '')))    { status = 'stale'; }
+    }
+    results.push({ tool: 'windsurf', status });
+  }
+
+  // Codex
+  if (!fs.existsSync(path.join(os.homedir(), '.codex'))) {
+    results.push({ tool: 'codex', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(CODEX_HOOKS_PATH)?.PreToolUse ?? [];
+    if (hooks.some(h => isCurrent(h?.command ?? '')))  results.push({ tool: 'codex', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.command ?? ''))) results.push({ tool: 'codex', status: 'stale' });
+    else                                                results.push({ tool: 'codex', status: 'not-installed' });
+  }
+
+  // Cline
+  if (!fs.existsSync(CLINE_HOOKS_DIR)) {
+    results.push({ tool: 'cline', status: 'tool-absent' });
+  } else {
+    let existing = '';
+    try { existing = fs.readFileSync(path.join(CLINE_HOOKS_DIR, 'PreToolUse'), 'utf8'); } catch {}
+    if (existing.includes(HOOK_VERSION))        results.push({ tool: 'cline', status: 'installed' });
+    else if (existing.includes('.omnitype'))    results.push({ tool: 'cline', status: 'stale' });
+    else                                         results.push({ tool: 'cline', status: 'not-installed' });
+  }
+
+  // GitHub Copilot
+  const hasVscode = fs.existsSync(path.join(os.homedir(), '.vscode')) ||
+    fs.existsSync(path.join(os.homedir(), 'Library', 'Application Support', 'Code'));
+  const hasCopilotDir = fs.existsSync(path.join(os.homedir(), '.copilot'));
+  if (!hasVscode && !hasCopilotDir) {
+    results.push({ tool: 'copilot', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(COPILOT_HOOKS_PATH)?.hooks?.PreToolUse ?? [];
+    if (hooks.some(h => isCurrent(h?.command ?? '')))   results.push({ tool: 'copilot', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.command ?? ''))) results.push({ tool: 'copilot', status: 'stale' });
+    else                                                 results.push({ tool: 'copilot', status: 'not-installed' });
+  }
+
+  // Gemini CLI
+  if (!fs.existsSync(path.join(os.homedir(), '.gemini'))) {
+    results.push({ tool: 'gemini-cli', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(GEMINI_SETTINGS_PATH)?.BeforeTool ?? [];
+    if (hooks.some(h => isCurrent(h?.hooks?.[0]?.command ?? '')))  results.push({ tool: 'gemini-cli', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.hooks?.[0]?.command ?? ''))) results.push({ tool: 'gemini-cli', status: 'stale' });
+    else                                                             results.push({ tool: 'gemini-cli', status: 'not-installed' });
+  }
+
+  // Droid
+  if (!fs.existsSync(path.join(os.homedir(), '.factory'))) {
+    results.push({ tool: 'droid', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(DROID_SETTINGS_PATH)?.PreToolUse ?? [];
+    if (hooks.some(h => isCurrent(h?.hooks?.[0]?.command ?? '')))  results.push({ tool: 'droid', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.hooks?.[0]?.command ?? ''))) results.push({ tool: 'droid', status: 'stale' });
+    else                                                             results.push({ tool: 'droid', status: 'not-installed' });
+  }
+
+  // Firebender
+  if (!fs.existsSync(path.join(os.homedir(), '.firebender'))) {
+    results.push({ tool: 'firebender', status: 'tool-absent' });
+  } else {
+    const hooks: any[] = readJson(FIREBENDER_HOOKS_PATH)?.preToolUse ?? [];
+    if (hooks.some(h => isCurrent(h?.command ?? '')))   results.push({ tool: 'firebender', status: 'installed' });
+    else if (hooks.some(h => isOurs(h?.command ?? ''))) results.push({ tool: 'firebender', status: 'stale' });
+    else                                                 results.push({ tool: 'firebender', status: 'not-installed' });
+  }
+
+  // Amp plugin
+  const ampDataDir = process.platform === 'win32'
+    ? path.join(process.env.LOCALAPPDATA ?? os.homedir(), 'amp')
+    : path.join(process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share'), 'amp');
+  if (!fs.existsSync(ampDataDir) && !fs.existsSync(AMP_PLUGINS_DIR)) {
+    results.push({ tool: 'amp', status: 'tool-absent' });
+  } else {
+    let src = '';
+    try { src = fs.readFileSync(AMP_PLUGIN_PATH, 'utf8'); } catch {}
+    if (src.includes(HOOK_VERSION))    results.push({ tool: 'amp', status: 'installed' });
+    else if (src.includes('.omnitype')) results.push({ tool: 'amp', status: 'stale' });
+    else                               results.push({ tool: 'amp', status: 'not-installed' });
+  }
+
+  // OpenCode plugin
+  if (!fs.existsSync(path.join(os.homedir(), '.config', 'opencode'))) {
+    results.push({ tool: 'opencode', status: 'tool-absent' });
+  } else {
+    let src = '';
+    try { src = fs.readFileSync(OPENCODE_PLUGIN_PATH, 'utf8'); } catch {}
+    if (src.includes(HOOK_VERSION))    results.push({ tool: 'opencode', status: 'installed' });
+    else if (src.includes('.omnitype')) results.push({ tool: 'opencode', status: 'stale' });
+    else                               results.push({ tool: 'opencode', status: 'not-installed' });
+  }
+
+  // Pi plugin
+  if (!fs.existsSync(path.join(os.homedir(), '.pi'))) {
+    results.push({ tool: 'pi', status: 'tool-absent' });
+  } else {
+    let src = '';
+    try { src = fs.readFileSync(PI_PLUGIN_PATH, 'utf8'); } catch {}
+    if (src.includes(HOOK_VERSION))    results.push({ tool: 'pi', status: 'installed' });
+    else if (src.includes('.omnitype')) results.push({ tool: 'pi', status: 'stale' });
+    else                               results.push({ tool: 'pi', status: 'not-installed' });
+  }
+
+  return results;
+}