@omnitype-code/cli 0.1.2 → 0.1.3

package/dist/core/ToolHookInstallers.js

@@ -1,11 +1,12 @@
 "use strict";
 /**
  * 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.
@@ -44,39 +45,50 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_VERSION = exports.GLOBAL_OMNITYPE_DIR = void 0;
 exports.installAllToolHooks = installAllToolHooks;
+exports.checkHookStatus = checkHookStatus;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const 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.
+exports.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.
+exports.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) => `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, modelField) {
-    return (`node -e "let b='';process.stdin.on('data',c=>b+=c);` +
+    return (`node -e "/*${exports.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{}})"`);
-}
-// 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.
-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'));` +
+        `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 "/*${exports.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) {
     try {
         return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -91,6 +103,17 @@ function writeJsonAtomic(filePath, data) {
     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) { return cmd.includes('.omnitype'); }
+/** True if a hook command belongs to us AND is current (no upgrade needed). */
+function isCurrent(cmd) { return cmd.includes(exports.HOOK_VERSION); }
+/** Remove stale omnitype entries from an array of hook objects (any shape). */
+function purgeStale(arr, cmdExtract) {
+    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');
@@ -106,11 +129,12 @@ function installClaudeHooks() {
         s.hooks = {};
     if (!Array.isArray(s.hooks.PreToolUse))
         s.hooks.PreToolUse = [];
-    const already = s.hooks.PreToolUse.some((h) => 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.some((h) => 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');
@@ -125,8 +149,8 @@ function installCursorHooks() {
     for (const event of ['preToolUse', 'postToolUse']) {
         if (!Array.isArray(settings.hooks[event]))
             settings.hooks[event] = [];
-        const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
-        if (!already) {
+        settings.hooks[event] = purgeStale(settings.hooks[event], h => h?.command);
+        if (!settings.hooks[event].some((h) => isCurrent(h?.command ?? ''))) {
             settings.hooks[event].push({ command: CURSOR_CMD });
             changed = true;
         }
@@ -156,8 +180,8 @@ function installWindsurfHooks() {
         for (const event of WINDSURF_EVENTS) {
             if (!Array.isArray(settings.hooks[event]))
                 settings.hooks[event] = [];
-            const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
-            if (!already) {
+            settings.hooks[event] = purgeStale(settings.hooks[event], h => h?.command);
+            if (!settings.hooks[event].some((h) => isCurrent(h?.command ?? ''))) {
                 settings.hooks[event].push({ command: WINDSURF_CMD });
                 changed = true;
             }
@@ -177,8 +201,8 @@ function installCodexHooks() {
     for (const event of ['PreToolUse', 'PostToolUse']) {
         if (!Array.isArray(settings[event]))
             settings[event] = [];
-        const already = settings[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
-        if (!already) {
+        settings[event] = purgeStale(settings[event], h => h?.command);
+        if (!settings[event].some((h) => isCurrent(h?.command ?? ''))) {
             settings[event].push({ type: 'command', command: CODEX_CMD });
             changed = true;
         }
@@ -189,9 +213,10 @@ function installCodexHooks() {
 // ── 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
+// ${exports.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);
@@ -199,11 +224,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 {}
 });
 `;
@@ -211,12 +241,226 @@ function installClineHooks() {
     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(exports.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() {
+    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].some((h) => 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() {
+    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.some((h) => 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() {
+    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].some((h) => 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
+// ${exports.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() {
+    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(exports.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 = `// ${exports.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() {
+    if (!fs.existsSync(path.join(os.homedir(), '.config', 'opencode')))
+        return;
+    let existing = '';
+    try {
+        existing = fs.readFileSync(OPENCODE_PLUGIN_PATH, 'utf8');
+    }
+    catch { }
+    if (existing.includes(exports.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 = `// ${exports.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() {
+    if (!fs.existsSync(path.join(os.homedir(), '.pi')))
+        return;
+    let existing = '';
+    try {
+        existing = fs.readFileSync(PI_PLUGIN_PATH, 'utf8');
+    }
+    catch { }
+    if (existing.includes(exports.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() {
+    // 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].some((h) => isCurrent(h?.command ?? ''))) {
+            s.hooks[ev].push({ type: 'command', command: COPILOT_CMD });
+            changed = true;
+        }
     }
+    if (changed)
+        writeJsonAtomic(COPILOT_HOOKS_PATH, s);
 }
 // ── Public API ────────────────────────────────────────────────────────────────
 function installAllToolHooks() {
@@ -240,4 +484,220 @@ function installAllToolHooks() {
         installClineHooks();
     }
     catch { }
+    try {
+        installCopilotHooks();
+    }
+    catch { }
+    try {
+        installGeminiHooks();
+    }
+    catch { }
+    try {
+        installDroidHooks();
+    }
+    catch { }
+    try {
+        installFirebenderHooks();
+    }
+    catch { }
+    try {
+        installAmpPlugin();
+    }
+    catch { }
+    try {
+        installOpenCodePlugin();
+    }
+    catch { }
+    try {
+        installPiPlugin();
+    }
+    catch { }
+}
+function checkHookStatus() {
+    const results = [];
+    // Claude Code
+    if (!fs.existsSync(CLAUDE_DIR)) {
+        results.push({ tool: 'claude-code', status: 'tool-absent' });
+    }
+    else {
+        const hooks = readJson(CLAUDE_SETTINGS)?.hooks?.PreToolUse ?? [];
+        const cmd = (h) => 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 = 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 = 'not-installed';
+        for (const hp of WINDSURF_HOOK_PATHS) {
+            const hooks = 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 = 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(exports.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 = 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 = 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 = 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 = 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(exports.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(exports.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(exports.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;
 }