@omnitype-code/cli 0.1.0

package/src/core/Heartbeat.ts

@@ -0,0 +1,53 @@
+/**
+ * Heartbeat coordination between the VS Code extension and the CLI daemon.
+ *
+ * The extension writes ~/.omnitype/vscode-heartbeat.json periodically.
+ * The daemon reads it before pushing to decide whether to yield.
+ *
+ * Schema: { pid: number, workspacePaths: string[], ts: number }
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const HEARTBEAT_PATH = path.join(os.homedir(), '.omnitype', 'vscode-heartbeat.json');
+const YIELD_WINDOW_MS = 30_000;  // daemon yields if extension was seen within 30s
+
+interface HeartbeatData {
+  pid: number;
+  workspacePaths: string[];
+  ts: number;
+}
+
+export function readExtensionHeartbeat(): HeartbeatData | null {
+  try {
+    const raw = fs.readFileSync(HEARTBEAT_PATH, 'utf8');
+    return JSON.parse(raw) as HeartbeatData;
+  } catch { return null; }
+}
+
+/**
+ * Returns true if the VS Code extension is actively tracking the given workspace.
+ * When true, the daemon should skip pushing for files in that workspace.
+ */
+export function extensionIsActiveFor(workspacePath: string): boolean {
+  const hb = readExtensionHeartbeat();
+  if (!hb) return false;
+  if (Date.now() - hb.ts > YIELD_WINDOW_MS) return false;
+  return hb.workspacePaths.some(p =>
+    workspacePath.startsWith(p) || p.startsWith(workspacePath)
+  );
+}
+
+/** Write our own daemon heartbeat so the extension can also yield to us if needed. */
+export function writeDaemonHeartbeat(watchPath: string): void {
+  try {
+    const data = { pid: process.pid, watchPath, ts: Date.now() };
+    fs.mkdirSync(path.dirname(HEARTBEAT_PATH), { recursive: true });
+    fs.writeFileSync(
+      path.join(os.homedir(), '.omnitype', 'daemon-heartbeat.json'),
+      JSON.stringify(data),
+    );
+  } catch { /* non-fatal */ }
+}

package/src/core/ModelDetector.ts

@@ -0,0 +1,216 @@
+/**
+ * CLI ModelDetector — editor-agnostic model detection.
+ *
+ * Detection tiers:
+ *   1. Universal sentinel   (~/.omnitype/active-model.json)
+ *   2. Hooks sentinel file  (~/.claude/provenance-hook.json)
+ *   3. Host IDE config      (Cursor/Windsurf/Zed settings.json — scanned generically)
+ *   4. Config files         (per-tool config paths: .aider.conf.yml, etc.)
+ *   5. Environment variables (CLAUDE_MODEL, AIDER_MODEL, etc.)
+ *   6. Process detection    (lsof / ps — identifies the writing process)
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+
+export interface ModelDetectionResult {
+  model: string;
+  tool: string;
+  confidence: 'deterministic' | 'high' | 'medium' | 'low';
+}
+
+const UNKNOWN: ModelDetectionResult = { model: 'unknown', tool: 'unknown', confidence: 'low' };
+const HOOKS_SENTINEL_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
+const UNIVERSAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+const SENTINEL_MAX_AGE_MS = 10_000;
+
+const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[1234](?:-[\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;
+
+// Maps known CLI/IDE env vars to their tool
+const ENV_VARS: Array<{ vars: string[]; tool: string }> = [
+  { vars: ['CLAUDE_MODEL', 'CLAUDE_CODE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
+  { vars: ['AIDER_MODEL'],                                           tool: 'aider' },
+  { vars: ['OPENAI_MODEL', 'OPENAI_API_MODEL'],                     tool: 'openai' },
+  { vars: ['GEMINI_MODEL', 'GEMINI_API_KEY'],                       tool: 'gemini-cli' },
+  { vars: ['OLLAMA_MODEL'],                                         tool: 'ollama' },
+  { vars: ['COPILOT_MODEL'],                                        tool: 'copilot' },
+  { vars: ['LLM_MODEL'],                                            tool: 'openhands' },
+  { vars: ['TABBY_MODEL'],                                          tool: 'tabby' },
+];
+
+const KNOWN_FORKS = [
+  'Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'
+];
+
+// lsof command-name → tool mapping
+const LSOF_CMD_MAP: Array<{ match: string; tool: string }> = [
+  { match: 'claude',    tool: 'claude-code' },
+  { match: 'aider',     tool: 'aider' },
+  { match: 'cursor',    tool: 'cursor' },
+  { match: 'windsurf',  tool: 'windsurf' },
+  { match: 'zed',       tool: 'zed' },
+  { match: 'pearai',    tool: 'pearai' },
+  { match: 'void',      tool: 'void' },
+  { match: 'tabby',     tool: 'tabby' },
+  { match: 'goose',     tool: 'goose' },
+  { match: 'node',      tool: 'unknown-cli' },
+  { match: 'python',    tool: 'unknown-cli' },
+];
+
+export class ModelDetector {
+  detect(changedFilePath?: string): ModelDetectionResult {
+    return (
+      this._fromUniversalSentinel() ??
+      this._fromHooksSentinel() ??
+      this._fromIdeConfigs() ??
+      this._fromEnv() ??
+      this._fromPsPatterns() ??
+      (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
+      UNKNOWN
+    );
+  }
+
+  private _fromUniversalSentinel(): ModelDetectionResult | undefined {
+    try {
+      const stat = fs.statSync(UNIVERSAL_SENTINEL_PATH);
+      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
+      const data = JSON.parse(fs.readFileSync(UNIVERSAL_SENTINEL_PATH, 'utf8'));
+      if (!data?.model || data.model === 'unknown') return undefined;
+      return { model: data.model, tool: data.tool ?? 'unknown-tool', confidence: 'deterministic' };
+    } catch { return undefined; }
+  }
+
+  private _fromHooksSentinel(): ModelDetectionResult | undefined {
+    try {
+      const stat = fs.statSync(HOOKS_SENTINEL_PATH);
+      if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS) return undefined;
+      const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
+      if (!data?.model || data.model === 'unknown') return undefined;
+      return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+    } catch { return undefined; }
+  }
+
+  private _fromIdeConfigs(): ModelDetectionResult | undefined {
+    for (const appName of KNOWN_FORKS) {
+      const scan = this._scanIdeSettings(appName);
+      if (scan) {
+        return { 
+          model: scan.model, 
+          tool: appName.toLowerCase(), 
+          confidence: scan.isAuto ? 'medium' : 'high' 
+        };
+      }
+    }
+    return undefined;
+  }
+
+  private _fromEnv(): ModelDetectionResult | undefined {
+    for (const { vars, tool } of ENV_VARS) {
+      for (const v of vars) {
+        const val = process.env[v];
+        if (val && MODEL_PATTERN.test(val)) {
+          return { model: val, tool, confidence: 'high' };
+        }
+      }
+    }
+    return undefined;
+  }
+
+  private _fromPsPatterns(): ModelDetectionResult | undefined {
+    if (process.platform === 'win32') return undefined;
+    try {
+      const lines = execFileSync('ps', ['ax', '-o', 'args='], { timeout: 800, encoding: 'utf8' }).split('\n');
+      for (const line of lines) {
+        for (const entry of LSOF_CMD_MAP) {
+          if (line.toLowerCase().includes(entry.match)) {
+            // Fallback model name
+            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
+          }
+        }
+      }
+    } catch { /* ps unavailable */ }
+    return undefined;
+  }
+
+  private _fromLsof(filePath: string): ModelDetectionResult | undefined {
+    if (process.platform === 'win32') return undefined;
+    try {
+      const out = execFileSync('lsof', ['-F', 'c', filePath], { timeout: 800, encoding: 'utf8' });
+      for (const line of out.split('\n')) {
+        if (!line.startsWith('c')) continue;
+        const cmd = line.slice(1).toLowerCase();
+        for (const entry of LSOF_CMD_MAP) {
+          if (cmd.includes(entry.match)) {
+            return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
+          }
+        }
+      }
+    } catch { /* lsof unavailable */ }
+    return undefined;
+  }
+
+  private _scanIdeSettings(appName: string): { model: string; isAuto: boolean } | undefined {
+    for (const p of this._getIdeSettingsPaths(appName)) {
+      try {
+        const raw = fs.readFileSync(p, 'utf8');
+        const json = JSON.parse(raw);
+        const flat = this._flattenObject(json);
+        
+        const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+        const candidates: Array<{ key: string; value: string }> = [];
+
+        for (const [key, value] of Object.entries(flat)) {
+          if (typeof value !== 'string' || !value) continue;
+          if (!key.toLowerCase().includes('model')) continue;
+
+          if (AUTO_SENTINELS.has(value.toLowerCase())) {
+            candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
+            continue;
+          }
+
+          if (MODEL_PATTERN.test(value)) {
+            candidates.push({ key, value: value.toLowerCase() });
+          }
+        }
+
+        if (candidates.length > 0) {
+          const real = candidates.filter(c => !c.value.endsWith('-auto'));
+          const pick = real.length > 0
+            ? real.sort((a, b) => b.key.length - a.key.length)[0]
+            : candidates.sort((a, b) => b.key.length - a.key.length)[0];
+          return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+        }
+      } catch { /* absent */ }
+    }
+    return undefined;
+  }
+
+  private _getIdeSettingsPaths(appName: string): string[] {
+    const toolId = appName.toLowerCase().replace(/\s+/g, '-');
+    const dirCandidates = [...new Set([appName, toolId])];
+
+    return dirCandidates.map(dir => {
+      switch (process.platform) {
+        case 'darwin': return path.join(os.homedir(), 'Library', 'Application Support', dir, 'User', 'settings.json');
+        case 'win32':  return path.join(process.env.APPDATA ?? '', dir, 'User', 'settings.json');
+        default:       return path.join(os.homedir(), '.config', dir, 'User', 'settings.json');
+      }
+    });
+  }
+
+  private _flattenObject(obj: Record<string, unknown>, prefix = '', depth = 0): Record<string, unknown> {
+    if (depth > 5) return {};
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(obj)) {
+      const key = prefix ? `${prefix}.${k}` : k;
+      if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+        Object.assign(out, this._flattenObject(v as Record<string, unknown>, key, depth + 1));
+      } else {
+        out[key] = v;
+      }
+    }
+    return out;
+  }
+}