@omnitype-code/cli 0.1.2 → 0.1.4

package/src/__tests__/ToolHookInstallersCoverage.test.ts

@@ -0,0 +1,237 @@
+/**
+ * ToolHookInstallers coverage tests — targets uncovered tool installers:
+ * Windsurf, Codex, Gemini, Droid, Firebender, Cline, Copilot, Amp, OpenCode, Pi
+ */
+
+import * as fs   from 'fs';
+import * as os   from 'os';
+import * as path from 'path';
+
+import {
+  installAllToolHooks,
+  checkHookStatus,
+  HOOK_VERSION,
+} from '../core/ToolHookInstallers';
+
+const HOME = os.homedir();
+
+function makeScratchDir(name: string): string {
+  const d = path.join(HOME, `.omnitype-cov-test-${name}-${Date.now()}`);
+  fs.mkdirSync(d, { recursive: true });
+  return d;
+}
+function rmDir(d: string) { fs.rmSync(d, { recursive: true, force: true }); }
+function readJson(p: string) { 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: string;
+  let scratchClaude: string;
+  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);
+    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: string;
+  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 });
+    installAllToolHooks();
+    const hooks = readJson(path.join(windsurfDir, 'hooks.json'));
+    const cmds: string[] = (hooks?.hooks?.pre_write_code ?? []).map((h: any) => h?.command ?? '');
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for windsurf', () => {
+    installAllToolHooks();
+    const statuses = 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 = checkHookStatus();
+    const ws = statuses.find(s => s.tool === 'windsurf');
+    expect(ws?.status).toBe('stale');
+  });
+});
+
+// ── Gemini CLI installer ──────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Gemini CLI', () => {
+  let scratchGemini: string;
+  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', () => {
+    installAllToolHooks();
+    const s = readJson(path.join(realGemini, 'settings.json'));
+    const cmds: string[] = (s?.BeforeTool ?? []).flatMap((e: any) => e?.hooks?.map((h: any) => h?.command ?? '') ?? []);
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for gemini-cli', () => {
+    installAllToolHooks();
+    const statuses = checkHookStatus();
+    const g = statuses.find(s => s.tool === 'gemini-cli');
+    expect(g?.status).toBe('installed');
+  });
+});
+
+// ── Codex installer ───────────────────────────────────────────────────────────
+
+describe('ToolHookInstallers — Codex', () => {
+  let scratchCodex: string;
+  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', () => {
+    installAllToolHooks();
+    const s = readJson(path.join(realCodex, 'hooks.json'));
+    const cmds: string[] = (s?.PreToolUse ?? []).map((h: any) => h?.command ?? '');
+    expect(cmds.some(c => c.includes(HOOK_VERSION))).toBe(true);
+  });
+
+  it('checkHookStatus returns installed for codex', () => {
+    installAllToolHooks();
+    const statuses = 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 = checkHookStatus();
+      const c = statuses.find(s => s.tool === 'cline');
+      expect(c?.status).toBe('tool-absent');
+      return;
+    }
+    installAllToolHooks();
+    const script = fs.readFileSync(path.join(clineDir, 'PreToolUse'), 'utf8');
+    expect(script).toContain(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(() => installAllToolHooks()).not.toThrow();
+  });
+
+  it('checkHookStatus returns array with entries for every tracked tool', () => {
+    const statuses = 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 = checkHookStatus();
+    for (const s of statuses) {
+      expect(valid.has(s.status)).toBe(true);
+    }
+  });
+});

package/src/__tests__/TranscriptScanner.test.ts

@@ -0,0 +1,201 @@
+/**
+ * TranscriptScanner Tests
+ *
+ * Tests the JSONL model-extraction logic and directory-scanning behaviour.
+ * All file I/O uses tmp directories — real ~/.claude is never touched.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// We import and test the public API plus the cache invalidation helper.
+import { scanTranscripts, invalidateTranscriptCache } from '../core/TranscriptScanner';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'omnitype-ts-'));
+}
+
+function rmTmp(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+/** Write a JSONL file with the given lines and return its path. */
+function writeJsonl(dir: string, name: string, lines: object[]): string {
+  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: string;
+  let origEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    tmp = makeTmp();
+    origEnv = { ...process.env };
+    invalidateTranscriptCache();
+    // Override CLAUDE_CONFIG_DIR so the scanner looks in our tmp dir
+    process.env.CLAUDE_CONFIG_DIR = tmp;
+  });
+
+  afterEach(() => {
+    process.env = origEnv;
+    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 = 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' } },
+    ]);
+
+    invalidateTranscriptCache();
+    const result = 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: '' },
+    ]);
+
+    invalidateTranscriptCache();
+    const result = 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');
+
+    invalidateTranscriptCache();
+    const result = scanTranscripts();
+    expect(result).toBeUndefined();
+  });
+
+  it('returns undefined when no session files exist', () => {
+    // tmp has CLAUDE_CONFIG_DIR but no projects dir at all
+    invalidateTranscriptCache();
+    const result = 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: '' },
+    ]);
+
+    invalidateTranscriptCache();
+    const first = 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 = 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');
+
+    invalidateTranscriptCache();
+    const result = 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');
+
+    invalidateTranscriptCache();
+    const result = 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' } },
+    ]);
+
+    invalidateTranscriptCache();
+    const resultA = scanTranscripts(cwdA);
+    invalidateTranscriptCache();
+    const resultB = scanTranscripts(cwdB);
+
+    expect(resultA?.model).toBe('claude-haiku-3');
+    expect(resultB?.model).toBe('claude-opus-4');
+  });
+});

package/src/core/ApiClient.ts

@@ -156,6 +156,21 @@ export 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: Array<{ id: string; name: string; hookSupport: string }>): void {
+    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
+  }
+
   private async _postWithRetry(url: string, body: unknown, attempts: number, label: string): Promise<void> {
     const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
     for (let i = 0; i < attempts; i++) {

package/src/core/ModelDetector.ts

@@ -11,9 +11,12 @@ export interface ModelDetectionResult {
 }
 
 const UNKNOWN: ModelDetectionResult = { model: 'unknown', tool: 'unknown', confidence: 'low' };
-const SENTINEL_MAX_AGE_MS = 30_000; // 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 = 30_000;
+const GLOBAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+
+function projectSentinelPath(cwd?: string): string {
+  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;
@@ -49,12 +52,12 @@ const PROC_MAP: Array<{ match: string; tool: string }> = [
 ];
 
 export class ModelDetector {
-  detect(changedFilePath?: string): ModelDetectionResult {
+  detect(changedFilePath?: string, cwd?: string): ModelDetectionResult {
     return (
-      this._sentinel(UNIVERSAL_PATH, changedFilePath) ??
-      this._sentinel(HOOKS_PATH, changedFilePath) ??
+      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) ??
@@ -62,8 +65,8 @@ export class ModelDetector {
     );
   }
 
-  private _fromTranscripts(): ModelDetectionResult | undefined {
-    const r = scanTranscripts();
+  private _fromTranscripts(cwd?: string): ModelDetectionResult | undefined {
+    const r = scanTranscripts(cwd);
     if (!r) return undefined;
     return { model: r.model, tool: r.tool, confidence: 'high' };
   }
@@ -100,6 +103,37 @@ export class ModelDetector {
       const scan = this._scanIdeSettings(appName);
       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;
+  }
+
+  private _fromCopilotConfig(): ModelDetectionResult | undefined {
+    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;
   }