@omnitype-code/cli 0.1.1 → 0.1.3

package/src/core/TranscriptScanner.ts

@@ -0,0 +1,320 @@
+/**
+ * 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: (cwd?: string) => string[];
+  ext: string;
+  extract: (p: string) => string | undefined;
+}
+
+/**
+ * Claude Code encodes a project path as the absolute path with '/' replaced by '-'.
+ * e.g. /Users/foo/myproject → -Users-foo-myproject
+ */
+function claudeProjectDir(cwd: string, base: string): string {
+  return path.join(base, 'projects', cwd.replace(/\//g, '-'));
+}
+
+/**
+ * Returns the VS Code workspaceStorage root, then filters subdirs to those
+ * whose workspace.json `folder` URI matches the given cwd.
+ * Falls back to returning all copilot transcript dirs if cwd is unknown.
+ */
+function copilotDirs(cwd?: string): string[] {
+  const roots: string[] = [];
+  switch (process.platform) {
+    case 'darwin':  roots.push(path.join(HOME, 'Library', 'Application Support', 'Code', 'User', 'workspaceStorage')); break;
+    case 'win32':   if (process.env.APPDATA) roots.push(path.join(process.env.APPDATA, 'Code', 'User', 'workspaceStorage')); break;
+    default:        roots.push(path.join(HOME, '.config', 'Code', 'User', 'workspaceStorage')); break;
+  }
+  // Also check Insiders
+  if (process.platform === 'darwin')
+    roots.push(path.join(HOME, 'Library', 'Application Support', 'Code - Insiders', 'User', 'workspaceStorage'));
+
+  const result: string[] = [];
+  for (const root of roots) {
+    if (!fs.existsSync(root)) continue;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const transcriptsDir = path.join(root, e.name, 'GitHub.copilot-chat', 'transcripts');
+      if (!fs.existsSync(transcriptsDir)) continue;
+      if (cwd) {
+        // Read workspace.json to check if this workspace matches the cwd
+        try {
+          const wj = JSON.parse(fs.readFileSync(path.join(root, e.name, 'workspace.json'), 'utf8'));
+          const folder = (wj?.folder ?? '').replace(/^file:\/\//, '').replace(/%20/g, ' ');
+          if (folder !== cwd && !folder.startsWith(cwd + '/')) continue;
+        } catch { continue; }
+      }
+      result.push(transcriptsDir);
+    }
+  }
+  return result;
+}
+
+/** Extract model from a Copilot JSONL event stream line. */
+function extractCopilotJsonl(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 buf = Buffer.alloc(readSize);
+    fs.readSync(fd, buf, 0, readSize, size - readSize);
+    fs.closeSync(fd); fd = undefined;
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const t = lines[i].trim();
+      if (!t) continue;
+      try {
+        const j = JSON.parse(t);
+        // assistant.message carries modelId in data
+        const m = j?.data?.modelId ?? j?.data?.model ?? j?.model ?? j?.message?.model;
+        if (typeof m === 'string' && m) return m;
+      } catch {}
+    }
+  } catch {}
+  finally { if (fd !== undefined) try { fs.closeSync(fd); } catch {} }
+  return undefined;
+}
+
+const SPECS: ToolSpec[] = [
+  {
+    tool: 'claude-code',
+    dirs: (cwd?: string) => {
+      const base = process.env.CLAUDE_CONFIG_DIR ?? path.join(HOME, '.claude');
+      const alt  = path.join(HOME, '.config', 'claude');
+      if (cwd) {
+        // Scope to the current workspace so other projects don't bleed in.
+        return [claudeProjectDir(cwd, base), claudeProjectDir(cwd, alt)];
+      }
+      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: 'copilot',
+    dirs: (cwd?: string) => copilotDirs(cwd),
+    ext: '.jsonl',
+    extract: extractCopilotJsonl,
+  },
+  {
+    tool: 'windsurf',
+    dirs: () => [path.join(HOME, '.codeium', 'windsurf', 'conversations')],
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+  {
+    tool: 'continue',
+    dirs: () => [path.join(HOME, '.continue', 'sessions')],
+    ext: '.json',
+    extract: (filePath: string) => {
+      try {
+        const msgs: any[] = JSON.parse(fs.readFileSync(filePath, 'utf8'))?.history ?? [];
+        for (let i = msgs.length - 1; i >= 0; i--) {
+          const m = msgs[i]?.message?.model ?? msgs[i]?.model;
+          if (typeof m === 'string' && m) return m;
+        }
+      } catch {}
+      return undefined;
+    },
+  },
+  {
+    // Copilot CLI: ~/.copilot/session-state/*/events.jsonl
+    tool: 'copilot-cli',
+    dirs: () => [path.join(HOME, '.copilot', 'session-state')],
+    ext: '.jsonl',
+    extract: extractJsonl,
+  },
+  {
+    tool: 'droid',
+    dirs: () => [path.join(HOME, '.factory', 'sessions')],
+    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;
+let _cacheCwd: string | undefined;
+
+/**
+ * Returns the model from the most recently modified AI session transcript.
+ * When `cwd` is provided, claude-code scanning is scoped to that workspace
+ * so activity from other projects doesn't bleed into the result.
+ * Result is cached for 60 s (cache is busted when cwd changes).
+ */
+export function scanTranscripts(cwd?: string): TranscriptResult | undefined {
+  if (_cache && _cacheCwd === cwd && Date.now() - _cacheAt < CACHE_TTL) return _cache;
+
+  let best: TranscriptResult | undefined;
+
+  for (const spec of SPECS) {
+    const file = newestFile(spec.dirs(cwd), 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();
+  _cacheCwd = cwd;
+  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,7 +60,21 @@ export function startDaemon(opts: { watchPath: string; projectName: string; bran
     process.exit(1);
   }
 
-  const watchPath   = path.resolve(opts.watchPath);
+  // Auto-install preToolUse hooks into all supported tools.
+  installAllToolHooks();
+
+  const watchPath = path.resolve(opts.watchPath);
+
+  // Initialize per-project .omnitype/ dir and ensure it is in .gitignore.
+  const omniDir = path.join(watchPath, '.omnitype');
+  try { fs.mkdirSync(omniDir, { recursive: true }); } catch {}
+  try {
+    const gitignore = path.join(watchPath, '.gitignore');
+    const current = fs.existsSync(gitignore) ? fs.readFileSync(gitignore, 'utf8') : '';
+    if (!current.split('\n').some(l => l.trim() === '.omnitype' || l.trim() === '.omnitype/')) {
+      fs.appendFileSync(gitignore, (current.length && !current.endsWith('\n') ? '\n' : '') + '.omnitype/\n');
+    }
+  } catch {}
   const projectName = opts.projectName;
   const branch      = opts.branch ?? gitBranch(watchPath);
 

package/src/index.ts

@@ -13,6 +13,8 @@ import { startDaemon } from './daemon';
 import { runBlame } from './blame';
 import { fetchNotes, pushNotes } from './core/GitNotes';
 import { UI, COLORS } from './core/UI';
+import { installAllToolHooks, checkHookStatus, type HookStatus } from './core/ToolHookInstallers';
+import { detectInstalledTools } from './core/ToolDetector';
 
 const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
 const program = new Command();
@@ -80,45 +82,146 @@ program
   .description('Show current auth and model detection status')
   .action(() => {
     const api = new ApiClient();
-    const detection = new ModelDetector().detect();
-    
-    let content = '';
-    
-    // Account Section
+    const cwd = process.cwd();
+    const detection = new ModelDetector().detect(undefined, cwd);
+
+    const lines: string[] = [];
+    const col1 = 10;
+    const lbl = (k: string) => chalk.bold(chalk.hex(COLORS.primary)(k.padEnd(col1)));
+
+    // Account
     if (api.isSignedIn) {
-      content += `${chalk.bold('Account:')}  ${chalk.cyan(api.username)}\n`;
-      content += `${chalk.bold('Server:')}   ${UI.dim(api.apiUrl)}\n`;
+      lines.push(`${lbl('Account')} ${chalk.cyan(api.username)}`);
+      lines.push(`${lbl('Server')} ${UI.dim(api.apiUrl)}`);
     } else {
-      content += `${chalk.bold('Account:')}  ${chalk.red('Not signed in')} ${UI.dim('(run: omnitype login)')}\n`;
+      lines.push(`${lbl('Account')} ${chalk.red('not signed in')}  ${UI.dim('→ omnitype login')}`);
     }
-    
-    content += `\n`;
-    
-    // Detection Section
-    content += `${chalk.bold('Current Context:')}\n`;
-    const modelColor = detection.model.includes('claude') ? '#D97757' : (detection.model.includes('gpt') ? '#10A37F' : COLORS.ai);
-    content += `  ${chalk.bold('Model:')}  ${chalk.hex(modelColor)(detection.model)}\n`;
-    content += `  ${chalk.bold('Tool:')}   ${chalk.white(detection.tool)}\n`;
-    
-    const confColors: Record<string, any> = {
-      deterministic: chalk.green('Deterministic'),
-      high: chalk.green('High'),
-      medium: chalk.yellow('Medium'),
-      low: chalk.red('Low'),
+
+    lines.push('');
+
+    // AI context
+    const toolColor = (t: string) =>
+      t.includes('claude') ? '#D97757' : t.includes('gpt') || t.includes('openai') ? '#10A37F'
+      : t.includes('gemini') ? '#4285F4' : t.includes('copilot') ? '#6E40C9' : COLORS.ai;
+
+    const modelStr = detection.model === 'unknown'
+      ? chalk.gray('none detected')
+      : chalk.bold(chalk.hex(toolColor(detection.model))(detection.model));
+
+    const toolStr = detection.tool === 'unknown'
+      ? chalk.gray('—')
+      : chalk.hex(toolColor(detection.tool))(detection.tool);
+
+    const confBadge: Record<string, string> = {
+      deterministic: chalk.bgGreen.black(' HOOK '),
+      high:          chalk.bgCyan.black(' HIGH '),
+      medium:        chalk.bgYellow.black(' MED  '),
+      low:           chalk.bgRed.black('  LOW '),
     };
-    content += `  ${chalk.bold('Conf:')}   ${confColors[detection.confidence] || detection.confidence}\n`;
 
-    // Repo Section
+    lines.push(`${lbl('Model')} ${modelStr}`);
+    lines.push(`${lbl('Tool')} ${toolStr}`);
+    lines.push(`${lbl('Confidence')} ${confBadge[detection.confidence] ?? detection.confidence}`);
+
+    // Repo
     try {
-      const gitBranch = require('child_process').execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
-      const gitRepo = path.basename(process.cwd());
-      content += `\n`;
-      content += `${chalk.bold('Repository:')}\n`;
-      content += `  ${chalk.bold('Project:')} ${gitRepo}\n`;
-      content += `  ${chalk.bold('Branch:')}  ${chalk.magenta(gitBranch)}`;
+      const cp = require('child_process');
+      const branch = cp.execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim();
+      const remote = (() => { try { return cp.execSync('git remote get-url origin', { cwd, encoding: 'utf8', stdio: ['pipe','pipe','pipe'] }).trim().replace(/^https?:\/\/[^/]+\//, '').replace(/\.git$/, ''); } catch { return ''; } })();
+      lines.push('');
+      lines.push(`${lbl('Project')} ${chalk.white(path.basename(cwd))}`);
+      lines.push(`${lbl('Branch')} ${chalk.magenta(branch)}`);
+      if (remote) lines.push(`${lbl('Remote')} ${UI.dim(remote)}`);
     } catch {}
 
-    console.log(UI.box(content, `${UI.logo()} Status`));
+    console.log(UI.box(lines.join('\n'), `${UI.logo()} Status`));
+  });
+
+// ── omnitype doctor ─────────────────────────────────────────────────────────
+program
+  .command('doctor')
+  .description('Check hook status for all detected AI tools')
+  .option('--fix', 'Auto-install or upgrade any missing/stale hooks')
+  .action((opts) => {
+    const api = new ApiClient();
+    const installed = detectInstalledTools();
+    const hookStatuses = checkHookStatus();
+    const hookMap = new Map(hookStatuses.map(s => [s.tool, s.status]));
+
+    const col = 20;
+    const lbl = (k: string) => chalk.bold(k.padEnd(col));
+
+    const hookBadge: Record<HookStatus, string> = {
+      'installed':     chalk.bgGreen.black('  HOOKED  '),
+      'stale':         chalk.bgYellow.black('  STALE   '),
+      'not-installed': chalk.bgRed.black(' NOT HOOKED'),
+      'tool-absent':   '',
+    };
+
+    const lines: string[] = [];
+    let needsFix = false;
+
+    const hookedTools    = installed.filter(t => t.hookSupport === 'hooked');
+    const configOnlyTools = installed.filter(t => t.hookSupport === 'config-only');
+    const unhooked        = installed.filter(t => t.hookSupport === 'no-hook');
+
+    // ── Tools with sentinel hook support ──
+    if (hookedTools.length > 0) {
+      lines.push(chalk.bold(chalk.hex(COLORS.primary)('Sentinel hooks:')));
+      for (const tool of hookedTools) {
+        const status = hookMap.get(tool.id) ?? 'not-installed';
+        lines.push(`  ${lbl(tool.name)} ${hookBadge[status]}`);
+        if (status === 'stale' || status === 'not-installed') needsFix = true;
+      }
+    } else {
+      lines.push(chalk.gray('No hookable AI tools detected on this machine.'));
+    }
+
+    // ── Config-only tools (model readable, no hook API) ──
+    if (configOnlyTools.length > 0) {
+      lines.push('');
+      lines.push(chalk.bold(chalk.hex(COLORS.secondary)('Config-readable (no hook API):')));
+      for (const tool of configOnlyTools) {
+        lines.push(`  ${lbl(tool.name)} ${chalk.hex(COLORS.secondary)(' DETECTED ')}  ${UI.dim('model readable from config')}`);
+      }
+    }
+
+    // ── Detected tools we don't support yet ──
+    if (unhooked.length > 0) {
+      lines.push('');
+      lines.push(chalk.bold(chalk.hex(COLORS.warning)('Detected (not yet supported):')));
+      for (const tool of unhooked) {
+        lines.push(`  ${lbl(tool.name)} ${chalk.gray('— support coming soon')}`);
+      }
+    }
+
+    // ── Nothing detected at all ──
+    if (installed.length === 0) {
+      lines.push(chalk.gray('No AI coding tools detected on this machine.'));
+      lines.push(UI.dim('Install Claude Code, Cursor, Windsurf, or another tool and re-run.'));
+    }
+
+    // ── Fix prompt ──
+    if (needsFix) {
+      lines.push('');
+      if (opts.fix) {
+        installAllToolHooks();
+        lines.push(chalk.hex(COLORS.success)('✔ Hooks installed/upgraded. Run doctor again to verify.'));
+      } else {
+        lines.push(chalk.yellow('→ Run with --fix to install or upgrade missing/stale hooks.'));
+        lines.push(UI.dim('  Hooks give deterministic (100% accurate) model attribution.'));
+      }
+    } else if (hookedTools.length > 0) {
+      lines.push('');
+      lines.push(chalk.hex(COLORS.success)('✔ All hooks up to date.'));
+    }
+
+    console.log(UI.box(lines.join('\n'), `${UI.logo()} Doctor`));
+
+    // Market analysis telemetry — fire and forget
+    if (installed.length > 0) {
+      api.reportToolEnvironment(installed.map(t => ({ id: t.id, name: t.name, hookSupport: t.hookSupport })));
+    }
   });
 
 // ── omnitype daemon ─────────────────────────────────────────────────────────