@omnitype-code/cli 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to the **@omnitype-code/cli** package are documented here.
 
 ---
 
+## [0.1.3] — 2026-05-16
+
+### Added
+- **`omnitype doctor`** — New command showing hook status for every detected tool: `installed`, `stale`, `not-installed`, or `tool-absent`. `--fix` flag auto-installs or upgrades missing hooks. Fires market-analysis telemetry (signed-in users only).
+- **`omnitype status` workspace fix** — Status command now passes `process.cwd()` into model detection, scoping Claude Code transcript scanning to the current workspace. Sessions from other concurrently open projects no longer bleed in.
+- **Per-project sentinel** — Hooks write to `<project_root>/.omnitype/active-model.json` (`process.cwd()` at invocation) in addition to `~/.omnitype/` fallback. `status` and `daemon` check project-local first, eliminating cross-window contamination.
+- **`initWorkspace()` in daemon** — `startDaemon()` creates `.omnitype/` in the watched directory and appends `.omnitype/` to `.gitignore` on first run.
+- **New hooks auto-installed** — Gemini CLI (`~/.gemini/settings.json` BeforeTool/AfterTool), Droid / Factory (`~/.factory/settings.json` PreToolUse), Firebender (`~/.firebender/hooks.json`), GitHub Copilot (`~/.copilot/hooks/omnitype.json`).
+- **New TS plugins** — Amp (`~/.config/amp/plugins/omnitype.ts`), OpenCode (`~/.config/opencode/plugins/omnitype.ts`), Pi (`~/.pi/agent/extensions/omnitype.ts`). Each dual-writes to project-local and global paths.
+- **New transcript readers** — `TranscriptScanner` now covers Continue (`~/.continue/sessions/`), Copilot CLI (`~/.copilot/session-state/`), and Droid (`~/.factory/sessions/`).
+- **`ToolDetector` updated** — Gemini CLI, Droid, Firebender, Amp, OpenCode, and Pi marked `hooked`.
+
+### Changed
+- **`HOOK_VERSION` bumped to `v4`** — All stale v3 hooks auto-replaced on next activation.
+- **Attribution Protocol upgraded to v1.2** — See `PROTOCOL.md`.
+
+---
+
 ## [0.1.2] — 2026-05-16
 
 ### Fixed

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);
+}