@omnitype-code/cli 0.1.2 → 0.1.3

package/src/core/ToolDetector.ts

@@ -0,0 +1,227 @@
+/**
+ * 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.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+
+/**
+ * hooked       — OmniType has a sentinel hook (deterministic attribution)
+ * config-only  — No hook API, but model is readable from config/extension (high confidence)
+ * no-hook      — Detected but no support yet
+ */
+export type HookSupport = 'hooked' | 'config-only' | 'no-hook';
+
+export interface KnownTool {
+  id: string;
+  name: string;
+  hookSupport: HookSupport;
+  /** Returns true if the tool appears to be installed on this machine. */
+  detect: () => boolean;
+}
+
+const HOME = os.homedir();
+
+function exists(...parts: string[]): boolean {
+  try { fs.accessSync(path.join(...parts)); return true; } catch { return false; }
+}
+
+function inPath(bin: string): boolean {
+  try { execFileSync('which', [bin], { timeout: 500, stdio: 'pipe' }); return true; } catch { return false; }
+}
+
+function macApp(name: string): boolean {
+  if (process.platform !== 'darwin') return false;
+  return exists('/Applications', name) || exists(HOME, 'Applications', name);
+}
+
+export const KNOWN_TOOLS: KnownTool[] = [
+  // ── 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'),
+  },
+];
+
+export interface DetectedTool {
+  tool: KnownTool;
+  detected: boolean;
+}
+
+/** Returns all known tools with a detected flag. */
+export function detectAllTools(): DetectedTool[] {
+  return KNOWN_TOOLS.map(tool => {
+    let detected = false;
+    try { detected = tool.detect(); } catch {}
+    return { tool, detected };
+  });
+}
+
+/** Returns only the tools that are actually installed. */
+export function detectInstalledTools(): KnownTool[] {
+  return detectAllTools().filter(r => r.detected).map(r => r.tool);
+}