@omnitype-code/cli 0.1.3 → 0.1.4

package/dist/__tests__/ToolHookInstallersCoverage.test.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * ToolHookInstallers coverage tests — targets uncovered tool installers:
+ * Windsurf, Codex, Gemini, Droid, Firebender, Cline, Copilot, Amp, OpenCode, Pi
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const ToolHookInstallers_1 = require("../core/ToolHookInstallers");
+const HOME = os.homedir();
+function makeScratchDir(name) {
+    const d = path.join(HOME, `.omnitype-cov-test-${name}-${Date.now()}`);
+    fs.mkdirSync(d, { recursive: true });
+    return d;
+}
+function rmDir(d) { fs.rmSync(d, { recursive: true, force: true }); }
+function readJson(p) { try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+catch {
+    return {};
+} }
+// ── Universal hook command content ────────────────────────────────────────────
+describe('ToolHookInstallers — universal hook command (all tools)', () => {
+    // Install into a scratch ~/.claude and read the command back
+    let cmd;
+    let scratchClaude;
+    const realClaude = path.join(HOME, '.claude');
+    const backup = path.join(HOME, `.claude-backup-cov-${Date.now()}`);
+    let hadReal = false;
+    beforeAll(() => {
+        scratchClaude = makeScratchDir('claude');
+        if (fs.existsSync(realClaude)) {
+            fs.renameSync(realClaude, backup);
+            hadReal = true;
+        }
+        fs.renameSync(scratchClaude, realClaude);
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const s = readJson(path.join(realClaude, 'settings.json'));
+        cmd = s?.hooks?.PreToolUse?.[0]?.hooks?.[0]?.command ?? '';
+        rmDir(realClaude);
+        if (hadReal)
+            fs.renameSync(backup, realClaude);
+    });
+    it('tries j.model (Cursor/Codex field)', () => {
+        expect(cmd).toContain('j.model');
+    });
+    it('tries j.model_name (Windsurf field)', () => {
+        expect(cmd).toContain('j.model_name');
+    });
+    it('tries j.modelName (camelCase variant)', () => {
+        expect(cmd).toContain('j.modelName');
+    });
+    it('tries j.modelID', () => {
+        expect(cmd).toContain('j.modelID');
+    });
+    it('tries j.data.model (nested variant)', () => {
+        expect(cmd).toContain('j?.data?.model');
+    });
+    it('falls back to transcript_path JSONL', () => {
+        expect(cmd).toContain('j.transcript_path');
+        expect(cmd).toContain('extractModelFromJsonl');
+    });
+    it('falls back to env var last', () => {
+        expect(cmd).toContain('CLAUDE_MODEL');
+        expect(cmd).toContain('ANTHROPIC_MODEL');
+    });
+});
+// ── Windsurf installer ────────────────────────────────────────────────────────
+describe('ToolHookInstallers — Windsurf', () => {
+    let scratchCodium;
+    const realCodium = path.join(HOME, '.codeium');
+    const backup = path.join(HOME, `.codeium-backup-${Date.now()}`);
+    let hadReal = false;
+    beforeEach(() => {
+        scratchCodium = makeScratchDir('codeium');
+        if (fs.existsSync(realCodium)) {
+            fs.renameSync(realCodium, backup);
+            hadReal = true;
+        }
+        fs.renameSync(scratchCodium, realCodium);
+    });
+    afterEach(() => {
+        rmDir(realCodium);
+        if (hadReal) {
+            fs.renameSync(backup, realCodium);
+            hadReal = false;
+        }
+    });
+    it('installs hook into windsurf/hooks.json', () => {
+        // The installer skips if neither hookPath nor its parent dir exists.
+        // Create the parent dir so it proceeds.
+        const windsurfDir = path.join(realCodium, 'windsurf');
+        fs.mkdirSync(windsurfDir, { recursive: true });
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const hooks = readJson(path.join(windsurfDir, 'hooks.json'));
+        const cmds = (hooks?.hooks?.pre_write_code ?? []).map((h) => h?.command ?? '');
+        expect(cmds.some(c => c.includes(ToolHookInstallers_1.HOOK_VERSION))).toBe(true);
+    });
+    it('checkHookStatus returns installed for windsurf', () => {
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        const ws = statuses.find(s => s.tool === 'windsurf');
+        expect(ws?.status).toBe('installed');
+    });
+    it('checkHookStatus returns stale when old hook present', () => {
+        const hooksDir = path.join(realCodium, 'windsurf');
+        fs.mkdirSync(hooksDir, { recursive: true });
+        fs.writeFileSync(path.join(hooksDir, 'hooks.json'), JSON.stringify({
+            hooks: { pre_write_code: [{ command: 'node -e "/*omnitype-hook-v3*/.omnitype"' }] }
+        }));
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        const ws = statuses.find(s => s.tool === 'windsurf');
+        expect(ws?.status).toBe('stale');
+    });
+});
+// ── Gemini CLI installer ──────────────────────────────────────────────────────
+describe('ToolHookInstallers — Gemini CLI', () => {
+    let scratchGemini;
+    const realGemini = path.join(HOME, '.gemini');
+    const backup = path.join(HOME, `.gemini-backup-${Date.now()}`);
+    let hadReal = false;
+    beforeEach(() => {
+        scratchGemini = makeScratchDir('gemini');
+        if (fs.existsSync(realGemini)) {
+            fs.renameSync(realGemini, backup);
+            hadReal = true;
+        }
+        fs.renameSync(scratchGemini, realGemini);
+    });
+    afterEach(() => {
+        rmDir(realGemini);
+        if (hadReal) {
+            fs.renameSync(backup, realGemini);
+            hadReal = false;
+        }
+    });
+    it('installs hook into gemini settings.json BeforeTool', () => {
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const s = readJson(path.join(realGemini, 'settings.json'));
+        const cmds = (s?.BeforeTool ?? []).flatMap((e) => e?.hooks?.map((h) => h?.command ?? '') ?? []);
+        expect(cmds.some(c => c.includes(ToolHookInstallers_1.HOOK_VERSION))).toBe(true);
+    });
+    it('checkHookStatus returns installed for gemini-cli', () => {
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        const g = statuses.find(s => s.tool === 'gemini-cli');
+        expect(g?.status).toBe('installed');
+    });
+});
+// ── Codex installer ───────────────────────────────────────────────────────────
+describe('ToolHookInstallers — Codex', () => {
+    let scratchCodex;
+    const realCodex = path.join(HOME, '.codex');
+    const backup = path.join(HOME, `.codex-backup-${Date.now()}`);
+    let hadReal = false;
+    beforeEach(() => {
+        scratchCodex = makeScratchDir('codex');
+        if (fs.existsSync(realCodex)) {
+            fs.renameSync(realCodex, backup);
+            hadReal = true;
+        }
+        fs.renameSync(scratchCodex, realCodex);
+    });
+    afterEach(() => {
+        rmDir(realCodex);
+        if (hadReal) {
+            fs.renameSync(backup, realCodex);
+            hadReal = false;
+        }
+    });
+    it('installs hook into codex hooks.json PreToolUse', () => {
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const s = readJson(path.join(realCodex, 'hooks.json'));
+        const cmds = (s?.PreToolUse ?? []).map((h) => h?.command ?? '');
+        expect(cmds.some(c => c.includes(ToolHookInstallers_1.HOOK_VERSION))).toBe(true);
+    });
+    it('checkHookStatus returns installed for codex', () => {
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        const c = statuses.find(s => s.tool === 'codex');
+        expect(c?.status).toBe('installed');
+    });
+});
+// ── Cline installer ───────────────────────────────────────────────────────────
+describe('ToolHookInstallers — Cline hook script content', () => {
+    it('Cline script contains version token', () => {
+        // The CLINE_HOOK_SCRIPT is embedded — verify via installing if dir exists
+        // otherwise just verify the constant is referenced in the module
+        const clineDir = path.join(HOME, 'Documents', 'Cline', 'Hooks');
+        if (!fs.existsSync(clineDir)) {
+            // Can't install, but we can verify the exported status
+            const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+            const c = statuses.find(s => s.tool === 'cline');
+            expect(c?.status).toBe('tool-absent');
+            return;
+        }
+        (0, ToolHookInstallers_1.installAllToolHooks)();
+        const script = fs.readFileSync(path.join(clineDir, 'PreToolUse'), 'utf8');
+        expect(script).toContain(ToolHookInstallers_1.HOOK_VERSION);
+        expect(script).toContain('extractModelFromJsonl');
+        expect(script).toContain('session.model_change');
+    });
+});
+// ── installAllToolHooks — silent on missing dirs ──────────────────────────────
+describe('ToolHookInstallers — installAllToolHooks resilience', () => {
+    it('does not throw even when all tool dirs are absent', () => {
+        // All real tool dirs may or may not exist — the function is always silent
+        expect(() => (0, ToolHookInstallers_1.installAllToolHooks)()).not.toThrow();
+    });
+    it('checkHookStatus returns array with entries for every tracked tool', () => {
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        const tools = statuses.map(s => s.tool);
+        expect(tools).toContain('claude-code');
+        expect(tools).toContain('cursor');
+        expect(tools).toContain('windsurf');
+        expect(tools).toContain('codex');
+        expect(tools).toContain('cline');
+        expect(tools).toContain('gemini-cli');
+    });
+    it('every status entry has valid status value', () => {
+        const valid = new Set(['installed', 'stale', 'not-installed', 'tool-absent']);
+        const statuses = (0, ToolHookInstallers_1.checkHookStatus)();
+        for (const s of statuses) {
+            expect(valid.has(s.status)).toBe(true);
+        }
+    });
+});

package/dist/__tests__/TranscriptScanner.test.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * TranscriptScanner Tests
+ *
+ * Tests the JSONL model-extraction logic and directory-scanning behaviour.
+ * All file I/O uses tmp directories — real ~/.claude is never touched.
+ */
+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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// We import and test the public API plus the cache invalidation helper.
+const TranscriptScanner_1 = require("../core/TranscriptScanner");
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function makeTmp() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'omnitype-ts-'));
+}
+function rmTmp(dir) {
+    fs.rmSync(dir, { recursive: true, force: true });
+}
+/** Write a JSONL file with the given lines and return its path. */
+function writeJsonl(dir, name, lines) {
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, name);
+    fs.writeFileSync(filePath, lines.map(l => JSON.stringify(l)).join('\n') + '\n', 'utf8');
+    return filePath;
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe('TranscriptScanner — extractJsonl (via scanTranscripts)', () => {
+    let tmp;
+    let origEnv;
+    beforeEach(() => {
+        tmp = makeTmp();
+        origEnv = { ...process.env };
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        // Override CLAUDE_CONFIG_DIR so the scanner looks in our tmp dir
+        process.env.CLAUDE_CONFIG_DIR = tmp;
+    });
+    afterEach(() => {
+        process.env = origEnv;
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        rmTmp(tmp);
+    });
+    it('reads model from message.model field in JSONL tail', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-project');
+        writeJsonl(projectDir, 'session1.jsonl', [
+            { type: 'system', content: 'hello' },
+            { type: 'assistant', message: { model: 'claude-sonnet-4-5', role: 'assistant' }, content: '' },
+        ]);
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(result).toBeDefined();
+        expect(result.model).toBe('claude-sonnet-4-5');
+    });
+    it('reads model from session.model_change event', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-model-change');
+        writeJsonl(projectDir, 'session2.jsonl', [
+            { type: 'system', content: 'start' },
+            { type: 'session.model_change', data: { newModel: 'claude-opus-4' } },
+        ]);
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(result).toBeDefined();
+        expect(result.model).toBe('claude-opus-4');
+    });
+    it('skips <synthetic> model values', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-synthetic');
+        writeJsonl(projectDir, 'session_synth.jsonl', [
+            { type: 'assistant', message: { model: '<synthetic>', role: 'assistant' }, content: '' },
+        ]);
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        // <synthetic> should be skipped — no valid model found
+        if (result) {
+            expect(result.model).not.toBe('<synthetic>');
+        }
+        // Result is either undefined or from another tool dir — not the synthetic value
+    });
+    it('returns undefined for empty JSONL file', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-empty');
+        const filePath = path.join(projectDir, 'empty.jsonl');
+        fs.mkdirSync(projectDir, { recursive: true });
+        fs.writeFileSync(filePath, '', 'utf8');
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(result).toBeUndefined();
+    });
+    it('returns undefined when no session files exist', () => {
+        // tmp has CLAUDE_CONFIG_DIR but no projects dir at all
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(result).toBeUndefined();
+    });
+    it('caches results and does not re-scan within TTL', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-cache');
+        writeJsonl(projectDir, 'sess.jsonl', [
+            { type: 'assistant', message: { model: 'claude-haiku-3', role: 'assistant' }, content: '' },
+        ]);
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const first = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(first?.model).toBe('claude-haiku-3');
+        // Now add a new file with a different model — but cache should return stale result
+        const projectDir2 = path.join(tmp, 'projects', '-tmp-cache2');
+        writeJsonl(projectDir2, 'sess2.jsonl', [
+            { type: 'assistant', message: { model: 'claude-opus-4', role: 'assistant' }, content: '' },
+        ]);
+        const second = (0, TranscriptScanner_1.scanTranscripts)(); // still within TTL
+        // Cache should return same result (the mtime of the new file might actually be newer
+        // in practice due to clock resolution — we verify the cache object is the same reference)
+        expect(second).toBe(first);
+    });
+    it('picks the most recently modified file when multiple sessions exist', async () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-multi');
+        fs.mkdirSync(projectDir, { recursive: true });
+        // Write older file first
+        const older = path.join(projectDir, 'old.jsonl');
+        fs.writeFileSync(older, JSON.stringify({ type: 'assistant', message: { model: 'claude-haiku-3' } }) + '\n');
+        // Set mtime to 1 second ago
+        const oldTime = new Date(Date.now() - 1000);
+        fs.utimesSync(older, oldTime, oldTime);
+        // Write newer file
+        const newer = path.join(projectDir, 'new.jsonl');
+        fs.writeFileSync(newer, JSON.stringify({ type: 'assistant', message: { model: 'claude-sonnet-4-5' } }) + '\n');
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        expect(result?.model).toBe('claude-sonnet-4-5');
+    });
+    it('falls back to head scan when file is large and model_change is near start', () => {
+        const projectDir = path.join(tmp, 'projects', '-tmp-large');
+        fs.mkdirSync(projectDir, { recursive: true });
+        const filePath = path.join(projectDir, 'large.jsonl');
+        // First line: model_change event
+        const firstLine = JSON.stringify({ type: 'session.model_change', data: { newModel: 'claude-opus-4' } }) + '\n';
+        // Pad with >50KB of data so the tail read won't include the first line
+        const padding = JSON.stringify({ type: 'padding', data: 'x'.repeat(512) }) + '\n';
+        let content = firstLine;
+        // Add enough padding lines to exceed 51200 bytes
+        while (content.length < 55000) {
+            content += padding;
+        }
+        fs.writeFileSync(filePath, content, 'utf8');
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const result = (0, TranscriptScanner_1.scanTranscripts)();
+        // The head fallback should find the model_change in the first line
+        expect(result).toBeDefined();
+        expect(result.model).toBe('claude-opus-4');
+    });
+    it('scopes claude-code scanning to the given cwd', () => {
+        // Write sessions for two different projects
+        const cwdA = '/fake/project-a';
+        const cwdB = '/fake/project-b';
+        const keyA = cwdA.replace(/\//g, '-');
+        const keyB = cwdB.replace(/\//g, '-');
+        const dirA = path.join(tmp, 'projects', keyA);
+        const dirB = path.join(tmp, 'projects', keyB);
+        writeJsonl(dirA, 'sess.jsonl', [
+            { type: 'assistant', message: { model: 'claude-haiku-3' } },
+        ]);
+        writeJsonl(dirB, 'sess.jsonl', [
+            { type: 'assistant', message: { model: 'claude-opus-4' } },
+        ]);
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const resultA = (0, TranscriptScanner_1.scanTranscripts)(cwdA);
+        (0, TranscriptScanner_1.invalidateTranscriptCache)();
+        const resultB = (0, TranscriptScanner_1.scanTranscripts)(cwdB);
+        expect(resultA?.model).toBe('claude-haiku-3');
+        expect(resultB?.model).toBe('claude-opus-4');
+    });
+});

package/dist/core/ToolHookInstallers.js

@@ -54,10 +54,8 @@ 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';
+exports.HOOK_VERSION = 'omnitype-hook-v5';
 // 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');` +
@@ -66,29 +64,49 @@ const WRITE_SENTINEL = (tool) => `const fs=require('fs'),p=require('path'),os=re
     `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',()=>{` +
+// Extracts model from a JSONL transcript by reading the tail (last 50KB).
+// Looks for message.model on assistant turns, or session.model_change events.
+// Same approach as git-ai's extract_model_from_jsonl_tail.
+const EXTRACT_MODEL_FROM_JSONL = `function extractModelFromJsonl(tp){` +
+    `try{` +
+    `const _fs=require('fs');` +
+    `const stat=_fs.statSync(tp);` +
+    `const readSize=Math.min(51200,stat.size);` +
+    `const buf=Buffer.alloc(readSize);` +
+    `const fd=_fs.openSync(tp,'r');` +
+    `_fs.readSync(fd,buf,0,readSize,stat.size-readSize);` +
+    `_fs.closeSync(fd);` +
+    `const lines=buf.toString('utf8').split('\\n').reverse();` +
+    `for(const line of lines){` +
+    `if(!line.trim())continue;` +
+    `try{const o=JSON.parse(line);` +
+    `if(o.type==='session.model_change'&&o.data&&o.data.newModel)return o.data.newModel;` +
+    `const m=o?.message?.model||o?.model;` +
+    `if(m&&m!=='<synthetic>')return m;` +
+    `}catch{}` +
+    `}` +
+    `}catch{}` +
+    `return null;` +
+    `}`;
+// Universal hook: works for every tool without per-tool customization.
+// Resolution order:
+//   1. Direct payload fields (covers Cursor, Windsurf, Codex, Cline, Gemini, etc.)
+//   2. transcript_path JSONL tail (covers Claude Code, Gemini — same as git-ai)
+//   3. Env vars as last resort
+function buildHookCommand(tool) {
+    return (`node -e "/*${exports.HOOK_VERSION}*/` +
+        EXTRACT_MODEL_FROM_JSONL +
+        `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{}` +
+        `let m=j.model||j.model_name||j.modelName||j.modelID||j?.data?.model||null;` +
+        `if(!m&&j.transcript_path)m=extractModelFromJsonl(j.transcript_path);` +
+        `if(!m)m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL||null;` +
+        `if(!m)return;` +
         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{}})"`;
+const CLAUDE_HOOK_CMD = buildHookCommand('claude-code');
 function readJson(filePath) {
     try {
         return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -138,7 +156,7 @@ function installClaudeHooks() {
 }
 // ── Cursor ────────────────────────────────────────────────────────────────────
 const CURSOR_HOOKS_PATH = path.join(os.homedir(), '.cursor', 'hooks.json');
-const CURSOR_CMD = buildHookCommand('cursor', 'model');
+const CURSOR_CMD = buildHookCommand('cursor');
 function installCursorHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.cursor')))
         return;
@@ -166,7 +184,7 @@ const WINDSURF_HOOK_PATHS = [
     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');
+const WINDSURF_CMD = buildHookCommand('windsurf');
 function installWindsurfHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.codeium')))
         return;
@@ -192,7 +210,7 @@ function installWindsurfHooks() {
 }
 // ── Codex ─────────────────────────────────────────────────────────────────────
 const CODEX_HOOKS_PATH = path.join(os.homedir(), '.codex', 'hooks.json');
-const CODEX_CMD = buildHookCommand('codex', 'model');
+const CODEX_CMD = buildHookCommand('codex');
 function installCodexHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.codex')))
         return;
@@ -218,13 +236,37 @@ 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']);
+function extractModelFromJsonl(tp) {
+  try {
+    const fs = require('fs');
+    const stat = fs.statSync(tp);
+    const readSize = Math.min(51200, stat.size);
+    const buf = Buffer.alloc(readSize);
+    const fd = fs.openSync(tp, 'r');
+    fs.readSync(fd, buf, 0, readSize, stat.size - readSize);
+    fs.closeSync(fd);
+    const lines = buf.toString('utf8').split('\\n').reverse();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const o = JSON.parse(line);
+        if (o.type === 'session.model_change' && o.data?.newModel) return o.data.newModel;
+        const m = o?.message?.model || o?.model;
+        if (m && m !== '<synthetic>') return m;
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
 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 m = j.model || j.model_name || j.modelName || j.modelID || j?.data?.model
+      || (j.transcript_path ? extractModelFromJsonl(j.transcript_path) : null)
+      || 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');
@@ -255,7 +297,7 @@ function installClineHooks() {
 // ── 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_CMD = buildHookCommand('gemini-cli');
 const GEMINI_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: GEMINI_CMD }] };
 function installGeminiHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.gemini')))
@@ -277,7 +319,7 @@ function installGeminiHooks() {
 // ── 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_CMD = buildHookCommand('droid');
 const DROID_HOOK_ENTRY = { matcher: '*', hooks: [{ type: 'command', command: DROID_CMD }] };
 function installDroidHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.factory')))
@@ -294,7 +336,7 @@ function installDroidHooks() {
 // ── 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');
+const FIREBENDER_CMD = buildHookCommand('firebender');
 function installFirebenderHooks() {
     if (!fs.existsSync(path.join(os.homedir(), '.firebender')))
         return;
@@ -438,7 +480,7 @@ function installPiPlugin() {
 // 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');
+const COPILOT_CMD = buildHookCommand('copilot');
 function installCopilotHooks() {
     // Require either ~/.copilot or ~/.vscode or VS Code settings to exist
     const hasVscode = fs.existsSync(path.join(os.homedir(), '.vscode')) ||