@omnitype-code/cli 0.1.0 → 0.1.2

package/dist/core/ToolHookInstallers.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Auto-installs OmniType model-detection hooks into AI tools that support
+ * a preToolUse/postToolUse hook system: Claude Code, Cursor, Windsurf, Codex, Cline.
+ *
+ * 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.
+ *
+ * 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.installAllToolHooks = installAllToolHooks;
+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.
+function buildHookCommand(tool, modelField) {
+    return (`node -e "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');` +
+        `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'));` +
+    `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})))})"`;
+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);
+}
+// ── 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 = [];
+    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);
+    }
+}
+// ── 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] = [];
+        const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+        if (!already) {
+            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] = [];
+            const already = settings.hooks[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+            if (!already) {
+                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] = [];
+        const already = settings[event].some((h) => typeof h?.command === 'string' && h.command.includes('.omnitype'));
+        if (!already) {
+            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.
+const CLINE_HOOKS_DIR = path.join(os.homedir(), 'Documents', 'Cline', 'Hooks');
+const CLINE_HOOK_SCRIPT = `#!/usr/bin/env node
+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 model = j.model || j.preToolUse?.model || '';
+    const fs = require('fs'), p = require('path'), os = require('os');
+    const dir = 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() }));
+  } catch {}
+});
+`;
+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);
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+function installAllToolHooks() {
+    try {
+        installClaudeHooks();
+    }
+    catch { }
+    try {
+        installCursorHooks();
+    }
+    catch { }
+    try {
+        installWindsurfHooks();
+    }
+    catch { }
+    try {
+        installCodexHooks();
+    }
+    catch { }
+    try {
+        installClineHooks();
+    }
+    catch { }
+}

package/dist/core/TranscriptScanner.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Transcript-based model detection — TypeScript port of git-ai's model_extraction.rs.
+ *
+ * Strategy: for each AI tool, find the most recently modified session file,
+ * read its tail (50 KB), scan lines in reverse for a model field, fall back
+ * to the head for tools that emit model_change events at session start.
+ *
+ * Results are cached for 60 s so directory scanning doesn't run on every edit.
+ */
+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.scanTranscripts = scanTranscripts;
+exports.invalidateTranscriptCache = invalidateTranscriptCache;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const TAIL_BYTES = 51200; // 50 KB — mirrors git-ai
+const HEAD_LINES = 20;
+const CACHE_TTL = 60000; // re-scan directories at most once per minute
+const HOME = os.homedir();
+// ── Model extraction from a single JSONL line ─────────────────────────────────
+function modelFromLine(line) {
+    const t = line.trim();
+    if (!t)
+        return undefined;
+    let j;
+    try {
+        j = JSON.parse(t);
+    }
+    catch {
+        return undefined;
+    }
+    // Copilot CLI / Windsurf: session.model_change event
+    if (j?.type === 'session.model_change') {
+        const m = j?.data?.newModel;
+        if (typeof m === 'string' && m)
+            return m;
+    }
+    // Standard JSONL: message.model, top-level model, or modelID
+    const candidate = j?.message?.model ?? j?.model ?? j?.modelID ?? j?.data?.model;
+    if (typeof candidate === 'string' && candidate && candidate !== '<synthetic>')
+        return candidate;
+    return undefined;
+}
+// ── JSONL extraction: tail scan + head fallback ───────────────────────────────
+function extractJsonl(filePath) {
+    let fd;
+    try {
+        fd = fs.openSync(filePath, 'r');
+        const size = fs.fstatSync(fd).size;
+        if (!size) {
+            fs.closeSync(fd);
+            return undefined;
+        }
+        const readSize = Math.min(TAIL_BYTES, size);
+        const seekPos = size - readSize;
+        const buf = Buffer.alloc(readSize);
+        fs.readSync(fd, buf, 0, readSize, seekPos);
+        fs.closeSync(fd);
+        fd = undefined;
+        // Reverse-scan the tail
+        const lines = buf.toString('utf8').split('\n');
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const m = modelFromLine(lines[i]);
+            if (m)
+                return m;
+        }
+        // Head fallback: model_change events are emitted at session start
+        if (seekPos > 0) {
+            const head = fs.readFileSync(filePath, 'utf8').split('\n');
+            for (let i = 0; i < Math.min(HEAD_LINES, head.length); i++) {
+                const m = modelFromLine(head[i]);
+                if (m)
+                    return m;
+            }
+        }
+    }
+    catch { /* unreadable */ }
+    finally {
+        if (fd !== undefined)
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+    }
+    return undefined;
+}
+// ── Amp: thread JSON — model lives in messages[].usage.model ─────────────────
+function extractAmp(filePath) {
+    try {
+        const messages = JSON.parse(fs.readFileSync(filePath, 'utf8'))?.messages ?? [];
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i]?.usage?.model;
+            if (typeof m === 'string' && m)
+                return m;
+        }
+    }
+    catch { }
+    return undefined;
+}
+const SPECS = [
+    {
+        tool: 'claude-code',
+        dirs: () => {
+            const base = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, '.claude');
+            const alt = path.join(HOME, '.config', 'claude');
+            return [path.join(base, 'projects'), path.join(alt, 'projects')];
+        },
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'codex',
+        dirs: () => [path.join(HOME, '.codex')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'gemini-cli',
+        dirs: () => [path.join(HOME, '.gemini', 'tmp')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+    {
+        tool: 'amp',
+        dirs: () => {
+            const xdg = process.env.XDG_DATA_HOME;
+            const local = process.env.LOCALAPPDATA;
+            if (process.platform === 'win32')
+                return local ? [path.join(local, 'amp', 'threads')] : [];
+            return [path.join(xdg ?? path.join(HOME, '.local', 'share'), 'amp', 'threads')];
+        },
+        ext: '.json',
+        extract: extractAmp,
+    },
+    {
+        tool: 'windsurf',
+        dirs: () => [path.join(HOME, '.codeium', 'windsurf', 'conversations')],
+        ext: '.jsonl',
+        extract: extractJsonl,
+    },
+];
+// ── Directory scanner: finds the newest file with the given extension ─────────
+function newestFile(dirs, ext) {
+    let best;
+    function scan(dir, depth = 0) {
+        if (depth > 6)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory())
+                scan(full, depth + 1);
+            else if (e.isFile() && e.name.endsWith(ext)) {
+                try {
+                    const mtime = fs.statSync(full).mtimeMs;
+                    if (!best || mtime > best.mtime)
+                        best = { path: full, mtime };
+                }
+                catch { }
+            }
+        }
+    }
+    for (const dir of dirs)
+        scan(dir);
+    return best;
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+let _cache;
+let _cacheAt = 0;
+/**
+ * Returns the model from the most recently modified AI session transcript,
+ * across all supported tools. Result is cached for 60 s.
+ */
+function scanTranscripts() {
+    if (_cache && Date.now() - _cacheAt < CACHE_TTL)
+        return _cache;
+    let best;
+    for (const spec of SPECS) {
+        const file = newestFile(spec.dirs(), spec.ext);
+        if (!file)
+            continue;
+        if (best && file.mtime <= best.mtime)
+            continue;
+        const model = spec.extract(file.path);
+        if (!model)
+            continue;
+        best = { model, tool: spec.tool, mtime: file.mtime };
+    }
+    _cache = best;
+    _cacheAt = Date.now();
+    return best;
+}
+function invalidateTranscriptCache() { _cache = undefined; _cacheAt = 0; }

package/dist/daemon.js

@@ -47,6 +47,7 @@ const ModelDetector_1 = require("./core/ModelDetector");
 const FileProvenance_1 = require("./core/FileProvenance");
 const Heartbeat_1 = require("./core/Heartbeat");
 const UI_1 = require("./core/UI");
+const ToolHookInstallers_1 = require("./core/ToolHookInstallers");
 const PUSH_INTERVAL_MS = 60000;
 const IDLE_PUSH_MS = 10000;
 const IGNORE_DIRS = /[/\\](\.git|node_modules|\.next|dist|build|__pycache__|\.venv|venv)[/\\]/;
@@ -90,6 +91,8 @@ function startDaemon(opts) {
         UI_1.UI.error('Not signed in. Run: omnitype login');
         process.exit(1);
     }
+    // Auto-install preToolUse hooks into Cursor, Windsurf, Codex if present.
+    (0, ToolHookInstallers_1.installAllToolHooks)();
     const watchPath = path.resolve(opts.watchPath);
     const projectName = opts.projectName;
     const branch = opts.branch ?? gitBranch(watchPath);

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@omnitype-code/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "OmniType CLI — editor-agnostic code provenance tracking",
+  "license": "MIT",
   "bin": {
     "omnitype": "./dist/index.js"
   },