@omnitype-code/cli 0.1.1 → 0.1.3

package/dist/core/ToolHookInstallers.js

@@ -0,0 +1,703 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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"));
+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 "/*${exports.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 "/*${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;` +
+    WRITE_SENTINEL('claude-code') +
+    `}catch{}})"`;
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJsonAtomic(filePath, data) {
+    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) { 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');
+const CLAUDE_HOOK_ENTRY = {
+    matcher: 'Write|Edit|MultiEdit|NotebookEdit',
+    hooks: [{ type: 'command', command: CLAUDE_HOOK_CMD }],
+};
+function installClaudeHooks() {
+    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.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');
+const CURSOR_CMD = buildHookCommand('cursor', 'model');
+function installCursorHooks() {
+    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].some((h) => 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() {
+    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].some((h) => 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() {
+    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].some((h) => 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
+// ${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);
+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() {
+    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(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() {
+    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 { }
+}
+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;
+}