@omnitype-code/cli 0.1.2 → 0.1.4

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/ApiClient.js

@@ -193,6 +193,21 @@ class ApiClient {
         if (failed.length)
             throw new Error(`Push failed for chunks: ${failed.join(', ')}`);
     }
+    /**
+     * Fire-and-forget: reports which AI tools are detected on this machine.
+     * Used for market analysis — understanding which tools users have alongside OmniType.
+     * Never throws. Only sends if the user is signed in (respects opt-in via login).
+     */
+    reportToolEnvironment(tools) {
+        if (!this.isSignedIn)
+            return;
+        const body = { tools, platform: process.platform, ts: Date.now() };
+        fetch(`${this.apiUrl}/telemetry/tools`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${this.config.token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        }).catch(() => { }); // best-effort, never surface errors
+    }
     async _postWithRetry(url, body, attempts, label) {
         const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
         for (let i = 0; i < attempts; i++) {

package/dist/core/ModelDetector.js

@@ -40,9 +40,11 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const TranscriptScanner_1 = require("./TranscriptScanner");
 const UNKNOWN = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-const SENTINEL_MAX_AGE_MS = 30000; // 30 s — covers slow multi-file AI diffs
-const UNIVERSAL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
-const HOOKS_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
+const SENTINEL_MAX_AGE_MS = 30000;
+const GLOBAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+function projectSentinelPath(cwd) {
+    return path.join(cwd ?? process.cwd(), '.omnitype', 'active-model.json');
+}
 // Matches model identifier strings from all major providers.
 const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[134](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
 // Each tool lists its OWN env vars only. Shared vars (OPENAI_MODEL) are NOT duplicated
@@ -72,18 +74,18 @@ const PROC_MAP = [
     { match: 'tabby', tool: 'tabby' },
 ];
 class ModelDetector {
-    detect(changedFilePath) {
-        return (this._sentinel(UNIVERSAL_PATH, changedFilePath) ??
-            this._sentinel(HOOKS_PATH, changedFilePath) ??
+    detect(changedFilePath, cwd) {
+        return (this._sentinel(projectSentinelPath(cwd), changedFilePath) ??
+            this._sentinel(GLOBAL_SENTINEL_PATH, changedFilePath) ??
             this._fromEnv() ??
-            this._fromTranscripts() ??
+            this._fromTranscripts(cwd) ??
             this._fromIdeConfigs() ??
             this._fromPs() ??
             (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
             UNKNOWN);
     }
-    _fromTranscripts() {
-        const r = (0, TranscriptScanner_1.scanTranscripts)();
+    _fromTranscripts(cwd) {
+        const r = (0, TranscriptScanner_1.scanTranscripts)(cwd);
         if (!r)
             return undefined;
         return { model: r.model, tool: r.tool, confidence: 'high' };
@@ -130,6 +132,38 @@ class ModelDetector {
             if (scan)
                 return { model: scan.model, tool: appName.toLowerCase(), confidence: scan.isAuto ? 'medium' : 'high' };
         }
+        // Copilot: no hook API, but model is readable from VS Code / fork settings.json
+        const copilot = this._fromCopilotConfig();
+        if (copilot)
+            return copilot;
+        return undefined;
+    }
+    _fromCopilotConfig() {
+        const COPILOT_KEYS = [
+            'github.copilot.advanced.model',
+            'github.copilot.selectedModel',
+            'github.copilot.chat.models.default',
+            'github.copilot.chat.agent.model',
+        ];
+        // Check VS Code and every known fork's settings.json
+        const vscodePaths = (() => {
+            switch (process.platform) {
+                case 'darwin': return [path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json')];
+                case 'win32': return [path.join(process.env.APPDATA ?? '', 'Code', 'User', 'settings.json')];
+                default: return [path.join(os.homedir(), '.config', 'Code', 'User', 'settings.json')];
+            }
+        })();
+        for (const settingsPath of vscodePaths) {
+            try {
+                const flat = this._flatten(JSON.parse(fs.readFileSync(settingsPath, 'utf8')));
+                for (const key of COPILOT_KEYS) {
+                    const val = flat[key];
+                    if (typeof val === 'string' && val && MODEL_PATTERN.test(val))
+                        return { model: val.toLowerCase(), tool: 'copilot', confidence: 'high' };
+                }
+            }
+            catch { }
+        }
         return undefined;
     }
     _fromPs() {

package/dist/core/ToolDetector.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * Detects every AI coding tool present on the machine, whether or not OmniType
+ * has a hook for it. Used by the doctor command and for market-analysis telemetry.
+ */
+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.KNOWN_TOOLS = void 0;
+exports.detectAllTools = detectAllTools;
+exports.detectInstalledTools = detectInstalledTools;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const HOME = os.homedir();
+function exists(...parts) {
+    try {
+        fs.accessSync(path.join(...parts));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function inPath(bin) {
+    try {
+        (0, child_process_1.execFileSync)('which', [bin], { timeout: 500, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function macApp(name) {
+    if (process.platform !== 'darwin')
+        return false;
+    return exists('/Applications', name) || exists(HOME, 'Applications', name);
+}
+exports.KNOWN_TOOLS = [
+    // ── Tools with OmniType hooks ────────────────────────────────────────────
+    {
+        id: 'claude-code',
+        name: 'Claude Code',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.claude') || inPath('claude'),
+    },
+    {
+        id: 'cursor',
+        name: 'Cursor',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.cursor') || macApp('Cursor.app'),
+    },
+    {
+        id: 'windsurf',
+        name: 'Windsurf',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.codeium') || macApp('Windsurf.app'),
+    },
+    {
+        id: 'codex',
+        name: 'Codex CLI',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.codex') || inPath('codex'),
+    },
+    {
+        id: 'cline',
+        name: 'Cline',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, 'Documents', 'Cline', 'Hooks') || exists(HOME, 'Documents', 'Cline'),
+    },
+    {
+        id: 'gemini-cli',
+        name: 'Gemini CLI',
+        hookSupport: 'hooked',
+        detect: () => inPath('gemini') || exists(HOME, '.gemini'),
+    },
+    {
+        id: 'droid',
+        name: 'Droid (Factory)',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.factory'),
+    },
+    {
+        id: 'firebender',
+        name: 'Firebender',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.firebender'),
+    },
+    {
+        id: 'amp',
+        name: 'Amp',
+        hookSupport: 'hooked',
+        detect: () => {
+            const xdg = process.env.XDG_DATA_HOME ?? path.join(HOME, '.local', 'share');
+            return inPath('amp') || exists(xdg, 'amp') ||
+                (process.platform === 'win32' && exists(process.env.LOCALAPPDATA ?? '', 'amp'));
+        },
+    },
+    {
+        id: 'opencode',
+        name: 'OpenCode',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.config', 'opencode') || inPath('opencode'),
+    },
+    {
+        id: 'pi',
+        name: 'Pi',
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.pi'),
+    },
+    // ── Tools detected but no hook yet ──────────────────────────────────────
+    {
+        id: 'aider',
+        name: 'Aider',
+        hookSupport: 'no-hook',
+        detect: () => inPath('aider') || exists(HOME, '.aider.conf.yml') || exists(HOME, '.aider'),
+    },
+    {
+        id: 'continue',
+        name: 'Continue',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.continue') || inPath('continue'),
+    },
+    {
+        id: 'antigravity',
+        name: 'Antigravity',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Antigravity.app') || macApp('Google Antigravity.app'),
+    },
+    {
+        id: 'pearai',
+        name: 'PearAI',
+        hookSupport: 'no-hook',
+        detect: () => macApp('PearAI.app') || exists(HOME, '.pearai'),
+    },
+    {
+        id: 'void',
+        name: 'Void',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Void.app') || exists(HOME, '.void'),
+    },
+    {
+        id: 'zed',
+        name: 'Zed',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Zed.app') ||
+            (process.platform === 'linux' && (inPath('zed') || exists(HOME, '.config', 'zed'))),
+    },
+    {
+        id: 'roo-cline',
+        name: 'Roo Code',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.roo') || exists(HOME, '.roo-cline'),
+    },
+    {
+        id: 'tabnine',
+        name: 'Tabnine',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.tabnine') || exists(HOME, '.config', 'tabnine'),
+    },
+    {
+        id: 'supermaven',
+        name: 'Supermaven',
+        hookSupport: 'no-hook',
+        detect: () => exists(HOME, '.supermaven'),
+    },
+    {
+        id: 'codeium',
+        name: 'Codeium',
+        hookSupport: 'no-hook',
+        // .codeium overlaps with Windsurf — only count if Windsurf isn't the reason
+        detect: () => exists(HOME, '.codeium', 'codeium') || exists(HOME, '.codeium', 'config'),
+    },
+    {
+        id: 'copilot',
+        name: 'GitHub Copilot',
+        // Copilot supports PreToolUse/PostToolUse hooks at ~/.copilot/hooks/
+        hookSupport: 'hooked',
+        detect: () => exists(HOME, '.copilot') ||
+            exists(HOME, '.vscode') ||
+            exists(HOME, 'Library', 'Application Support', 'Code') ||
+            exists(HOME, '.config', 'github-copilot'),
+    },
+    {
+        id: 'trae',
+        name: 'Trae',
+        hookSupport: 'no-hook',
+        detect: () => macApp('Trae.app') || exists(HOME, '.trae'),
+    },
+    {
+        id: 'goose',
+        name: 'Goose',
+        hookSupport: 'no-hook',
+        detect: () => inPath('goose') || exists(HOME, '.config', 'goose'),
+    },
+    {
+        id: 'openai-codex-legacy',
+        name: 'OpenAI Codex (legacy)',
+        hookSupport: 'no-hook',
+        detect: () => !!process.env.OPENAI_API_KEY && !exists(HOME, '.codex'),
+    },
+];
+/** Returns all known tools with a detected flag. */
+function detectAllTools() {
+    return exports.KNOWN_TOOLS.map(tool => {
+        let detected = false;
+        try {
+            detected = tool.detect();
+        }
+        catch { }
+        return { tool, detected };
+    });
+}
+/** Returns only the tools that are actually installed. */
+function detectInstalledTools() {
+    return detectAllTools().filter(r => r.detected).map(r => r.tool);
+}