@omnitype-code/cli 0.1.2 → 0.1.3

package/src/core/ToolHookInstallers.ts

@@ -1,10 +1,11 @@
 /**
  * Auto-installs OmniType model-detection hooks into AI tools that support
- * a preToolUse/postToolUse hook system: Claude Code, Cursor, Windsurf, Codex, Cline.
+ * a preToolUse/postToolUse hook system.
  *
- * Hooks write {model, tool, ts, file} to ~/.omnitype/active-model.json.
- * Including the target file path lets the detector use path-matching instead
- * of a short TTL — eliminating the race between human and AI edits.
+ * 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.
@@ -14,41 +15,52 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
-const OMNITYPE_DIR = path.join(os.homedir(), '.omnitype');
+export const GLOBAL_OMNITYPE_DIR = path.join(os.homedir(), '.omnitype');
 
-// Reads stdin JSON, extracts model + file path, writes sentinel.
-// `modelField` is the tool-specific key for model in the hook payload.
+// 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 "let b='';process.stdin.on('data',c=>b+=c);` +
+    `node -e "/*${HOOK_VERSION}*/let b='';process.stdin.on('data',c=>b+=c);` +
     `process.stdin.on('end',()=>{` +
-    `try{const j=JSON.parse(b),` +
-    `m=j['${modelField}']||j.model,` +
-    `fs=require('fs'),p=require('path'),os=require('os'),` +
-    `dir=p.join(os.homedir(),'.omnitype');` +
+    `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;}catch{}` +
-    `fs.mkdirSync(dir,{recursive:true});` +
-    `fs.writeFileSync(p.join(dir,'active-model.json'),` +
-    `JSON.stringify(Object.assign({model:m,tool:'${tool}',ts:Date.now()},file&&{file})))}catch{}})"`
+    `let file;try{file=j?.tool_input?.path||j?.tool_input?.file_path||j?.toolInput?.path;}catch{}` +
+    WRITE_SENTINEL(tool) +
+    `}catch{}})"`
   );
 }
 
-// Claude doesn't expose model in hook stdin — reads from env/settings instead.
-// Still reads stdin to extract the target file path for path-gated matching.
+// Claude Code hook: reads model from stdin first, then env, then settings.json.
 const CLAUDE_HOOK_CMD =
-  `node -e "let b='';process.stdin.on('data',c=>b+=c);process.stdin.on('end',()=>{` +
-  `const fs=require('fs'),os=require('os'),p=require('path');` +
-  `const dir=p.join(os.homedir(),'.omnitype');` +
-  `let m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL;` +
-  `if(!m){try{const s=JSON.parse(fs.readFileSync(p.join(os.homedir(),'.claude','settings.json'),'utf8'));` +
+  `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;` +
-  `let file;try{const j=JSON.parse(b);file=j?.tool_input?.path||j?.tool_input?.file_path;}catch{}` +
-  `fs.mkdirSync(dir,{recursive:true});` +
-  `fs.writeFileSync(p.join(dir,'active-model.json'),` +
-  `JSON.stringify(Object.assign({model:m,tool:'claude-code',ts:Date.now()},file&&{file})))})"`;
-
+  WRITE_SENTINEL('claude-code') +
+  `}catch{}})"`;
 function readJson(filePath: string): Record<string, any> {
   try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return {}; }
 }
@@ -60,6 +72,20 @@ function writeJsonAtomic(filePath: string, data: unknown): void {
   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');
@@ -74,10 +100,11 @@ function installClaudeHooks(): void {
   const s = readJson(CLAUDE_SETTINGS);
   if (!s.hooks) s.hooks = {};
   if (!Array.isArray(s.hooks.PreToolUse)) s.hooks.PreToolUse = [];
-  const already = (s.hooks.PreToolUse as any[]).some(
-    (h: any) => typeof h?.hooks?.[0]?.command === 'string' && h.hooks[0].command.includes('.omnitype')
-  );
-  if (!already) { s.hooks.PreToolUse.push(CLAUDE_HOOK_ENTRY); writeJsonAtomic(CLAUDE_SETTINGS, s); }
+  // 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 ────────────────────────────────────────────────────────────────────
@@ -92,10 +119,10 @@ function installCursorHooks(): void {
   let changed = false;
   for (const event of ['preToolUse', 'postToolUse']) {
     if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
-    const already = (settings.hooks[event] as any[]).some(
-      (h: any) => typeof h?.command === 'string' && h.command.includes('.omnitype')
-    );
-    if (!already) { settings.hooks[event].push({ command: CURSOR_CMD }); changed = true; }
+    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);
@@ -119,10 +146,10 @@ function installWindsurfHooks(): void {
     let changed = false;
     for (const event of WINDSURF_EVENTS) {
       if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
-      const already = (settings.hooks[event] as any[]).some(
-        (h: any) => typeof h?.command === 'string' && h.command.includes('.omnitype')
-      );
-      if (!already) { settings.hooks[event].push({ command: WINDSURF_CMD }); changed = true; }
+      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);
   }
@@ -139,10 +166,10 @@ function installCodexHooks(): void {
   let changed = false;
   for (const event of ['PreToolUse', 'PostToolUse']) {
     if (!Array.isArray(settings[event])) settings[event] = [];
-    const already = (settings[event] as any[]).some(
-      (h: any) => typeof h?.command === 'string' && h.command.includes('.omnitype')
-    );
-    if (!already) { settings[event].push({ type: 'command', command: CODEX_CMD }); changed = true; }
+    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);
 }
@@ -150,10 +177,11 @@ function installCodexHooks(): void {
 // ── 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.
+// 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);
@@ -161,11 +189,16 @@ process.stdin.on('end', () => {
   try {
     const j = JSON.parse(buf);
     if (!FILE_WRITE_TOOLS.has(j.toolName)) return;
-    const model = j.model || j.preToolUse?.model || '';
+    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(os.homedir(), '.omnitype');
+    const dir = p.join(process.cwd(), '.omnitype');
+    const fbDir = p.join(os.homedir(), '.omnitype');
     fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(p.join(dir, 'active-model.json'), JSON.stringify({ model, tool: 'cline', ts: Date.now() }));
+    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 {}
 });
 `;
@@ -173,12 +206,213 @@ process.stdin.on('end', () => {
 function installClineHooks(): void {
   if (!fs.existsSync(CLINE_HOOKS_DIR)) return;
   const scriptPath = path.join(CLINE_HOOKS_DIR, 'PreToolUse');
-  const already = fs.existsSync(scriptPath) &&
-    fs.readFileSync(scriptPath, 'utf8').includes('.omnitype');
-  if (!already) {
-    fs.writeFileSync(scriptPath, CLINE_HOOK_SCRIPT, 'utf8');
-    fs.chmodSync(scriptPath, 0o755);
+  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 ────────────────────────────────────────────────────────────────
@@ -189,4 +423,158 @@ export function installAllToolHooks(): void {
   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;
 }