@omnitype-code/cli 0.1.0 → 0.1.2

package/src/core/TranscriptScanner.ts

@@ -0,0 +1,204 @@
+/**
+ * Transcript-based model detection — TypeScript port of git-ai's model_extraction.rs.
+ *
+ * Strategy: for each AI tool, find the most recently modified session file,
+ * read its tail (50 KB), scan lines in reverse for a model field, fall back
+ * to the head for tools that emit model_change events at session start.
+ *
+ * Results are cached for 60 s so directory scanning doesn't run on every edit.
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface TranscriptResult {
+  model: string;
+  tool: string;
+  /** mtime of the session file — callers can use this to judge freshness. */
+  mtime: number;
+}
+
+const TAIL_BYTES  = 51_200; // 50 KB — mirrors git-ai
+const HEAD_LINES  = 20;
+const CACHE_TTL   = 60_000; // re-scan directories at most once per minute
+const HOME        = os.homedir();
+
+// ── Model extraction from a single JSONL line ─────────────────────────────────
+
+function modelFromLine(line: string): string | undefined {
+  const t = line.trim();
+  if (!t) return undefined;
+  let j: any;
+  try { j = JSON.parse(t); } catch { return undefined; }
+
+  // Copilot CLI / Windsurf: session.model_change event
+  if (j?.type === 'session.model_change') {
+    const m = j?.data?.newModel;
+    if (typeof m === 'string' && m) return m;
+  }
+
+  // Standard JSONL: message.model, top-level model, or modelID
+  const candidate = j?.message?.model ?? j?.model ?? j?.modelID ?? j?.data?.model;
+  if (typeof candidate === 'string' && candidate && candidate !== '<synthetic>')
+    return candidate;
+
+  return undefined;
+}
+
+// ── JSONL extraction: tail scan + head fallback ───────────────────────────────
+
+function extractJsonl(filePath: string): string | undefined {
+  let fd: number | undefined;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const size = fs.fstatSync(fd).size;
+    if (!size) { fs.closeSync(fd); return undefined; }
+
+    const readSize = Math.min(TAIL_BYTES, size);
+    const seekPos  = size - readSize;
+    const buf = Buffer.alloc(readSize);
+    fs.readSync(fd, buf, 0, readSize, seekPos);
+    fs.closeSync(fd);
+    fd = undefined;
+
+    // Reverse-scan the tail
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const m = modelFromLine(lines[i]);
+      if (m) return m;
+    }
+
+    // Head fallback: model_change events are emitted at session start
+    if (seekPos > 0) {
+      const head = fs.readFileSync(filePath, 'utf8').split('\n');
+      for (let i = 0; i < Math.min(HEAD_LINES, head.length); i++) {
+        const m = modelFromLine(head[i]);
+        if (m) return m;
+      }
+    }
+  } catch { /* unreadable */ }
+  finally { if (fd !== undefined) try { fs.closeSync(fd); } catch {} }
+  return undefined;
+}
+
+// ── Amp: thread JSON — model lives in messages[].usage.model ─────────────────
+
+function extractAmp(filePath: string): string | undefined {
+  try {
+    const messages: any[] = JSON.parse(fs.readFileSync(filePath, 'utf8'))?.messages ?? [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i]?.usage?.model;
+      if (typeof m === 'string' && m) return m;
+    }
+  } catch {}
+  return undefined;
+}
+
+// ── Tool specs: where each tool stores transcripts ────────────────────────────
+
+interface ToolSpec {
+  tool: string;
+  dirs: () => string[];
+  ext: string;
+  extract: (p: string) => string | undefined;
+}
+
+const SPECS: ToolSpec[] = [
+  {
+    tool: 'claude-code',
+    dirs: () => {
+      const base = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, '.claude');
+      const alt  = path.join(HOME, '.config', 'claude');
+      return [path.join(base, 'projects'), path.join(alt, 'projects')];
+    },
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+  {
+    tool: 'codex',
+    dirs: () => [path.join(HOME, '.codex')],
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+  {
+    tool: 'gemini-cli',
+    dirs: () => [path.join(HOME, '.gemini', 'tmp')],
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+  {
+    tool: 'amp',
+    dirs: () => {
+      const xdg   = process.env.XDG_DATA_HOME;
+      const local  = process.env.LOCALAPPDATA;
+      if (process.platform === 'win32') return local ? [path.join(local, 'amp', 'threads')] : [];
+      return [path.join(xdg ?? path.join(HOME, '.local', 'share'), 'amp', 'threads')];
+    },
+    ext: '.json',
+    extract: extractAmp,
+  },
+  {
+    tool: 'windsurf',
+    dirs: () => [path.join(HOME, '.codeium', 'windsurf', 'conversations')],
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+];
+
+// ── Directory scanner: finds the newest file with the given extension ─────────
+
+function newestFile(dirs: string[], ext: string): { path: string; mtime: number } | undefined {
+  let best: { path: string; mtime: number } | undefined;
+
+  function scan(dir: string, depth = 0): void {
+    if (depth > 6) return;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) scan(full, depth + 1);
+      else if (e.isFile() && e.name.endsWith(ext)) {
+        try {
+          const mtime = fs.statSync(full).mtimeMs;
+          if (!best || mtime > best.mtime) best = { path: full, mtime };
+        } catch {}
+      }
+    }
+  }
+
+  for (const dir of dirs) scan(dir);
+  return best;
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+let _cache: TranscriptResult | undefined;
+let _cacheAt = 0;
+
+/**
+ * Returns the model from the most recently modified AI session transcript,
+ * across all supported tools. Result is cached for 60 s.
+ */
+export function scanTranscripts(): TranscriptResult | undefined {
+  if (_cache && Date.now() - _cacheAt < CACHE_TTL) return _cache;
+
+  let best: TranscriptResult | undefined;
+
+  for (const spec of SPECS) {
+    const file = newestFile(spec.dirs(), spec.ext);
+    if (!file) continue;
+    if (best && file.mtime <= best.mtime) continue;
+
+    const model = spec.extract(file.path);
+    if (!model) continue;
+
+    best = { model, tool: spec.tool, mtime: file.mtime };
+  }
+
+  _cache  = best;
+  _cacheAt = Date.now();
+  return best;
+}
+
+export function invalidateTranscriptCache(): void { _cache = undefined; _cacheAt = 0; }

package/src/daemon.ts

@@ -9,6 +9,7 @@ import { FileProvenance } from './core/FileProvenance';
 import type { StoredProvenance, LineHashBaseline } from './core/FileProvenance';
 import { extensionIsActiveFor, writeDaemonHeartbeat } from './core/Heartbeat';
 import { UI, COLORS } from './core/UI';
+import { installAllToolHooks } from './core/ToolHookInstallers';
 
 const PUSH_INTERVAL_MS = 60_000;
 const IDLE_PUSH_MS     = 10_000;
@@ -59,6 +60,9 @@ export function startDaemon(opts: { watchPath: string; projectName: string; bran
     process.exit(1);
   }
 
+  // Auto-install preToolUse hooks into Cursor, Windsurf, Codex if present.
+  installAllToolHooks();
+
   const watchPath   = path.resolve(opts.watchPath);
   const projectName = opts.projectName;
   const branch      = opts.branch ?? gitBranch(watchPath);