@omnitype-code/cli 0.1.0

package/src/index.ts

@@ -0,0 +1,537 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { ApiClient } from './core/ApiClient';
+import { ModelDetector } from './core/ModelDetector';
+import { installHooks, uninstallHooks, commitScan } from './hooks';
+import { startDaemon } from './daemon';
+import { runBlame } from './blame';
+import { fetchNotes, pushNotes } from './core/GitNotes';
+import { UI, COLORS } from './core/UI';
+
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+const program = new Command();
+
+program
+  .name('omnitype')
+  .description('Code provenance tracking — works with any editor or AI tool')
+  .version(pkg.version);
+
+// ── omnitype login ──────────────────────────────────────────────────────────
+program
+  .command('login')
+  .description('Sign in to OmniType')
+  .option('--email <email>', 'Email address')
+  .option('--password <password>', 'Password')
+  .action(async (opts) => {
+    console.log(UI.banner());
+    
+    const api = new ApiClient();
+    
+    const answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'email',
+        message: 'Email address:',
+        when: !opts.email,
+        validate: (input: string) => input.includes('@') || 'Please enter a valid email',
+      },
+      {
+        type: 'password',
+        name: 'password',
+        message: 'Password:',
+        mask: '*',
+        when: !opts.password,
+      }
+    ]);
+
+    const email = opts.email || answers.email;
+    const password = opts.password || answers.password;
+
+    const spinner = UI.spinner('Authenticating with OmniType Cloud...');
+    try {
+      const username = await api.login(email, password);
+      spinner.succeed(`Welcome back, ${UI.bold(username)}!`);
+      UI.success('You are now signed in.');
+    } catch (err: any) {
+      spinner.fail('Authentication failed');
+      UI.error(err.message || String(err));
+      process.exit(1);
+    }
+  });
+
+// ── omnitype logout ─────────────────────────────────────────────────────────
+program
+  .command('logout')
+  .description('Sign out')
+  .action(() => {
+    new ApiClient().logout();
+    UI.success('Signed out successfully.');
+  });
+
+// ── omnitype status ─────────────────────────────────────────────────────────
+program
+  .command('status')
+  .description('Show current auth and model detection status')
+  .action(() => {
+    const api = new ApiClient();
+    const detection = new ModelDetector().detect();
+    
+    let content = '';
+    
+    // Account Section
+    if (api.isSignedIn) {
+      content += `${chalk.bold('Account:')}  ${chalk.cyan(api.username)}\n`;
+      content += `${chalk.bold('Server:')}   ${UI.dim(api.apiUrl)}\n`;
+    } else {
+      content += `${chalk.bold('Account:')}  ${chalk.red('Not signed in')} ${UI.dim('(run: omnitype login)')}\n`;
+    }
+    
+    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'),
+    };
+    content += `  ${chalk.bold('Conf:')}   ${confColors[detection.confidence] || detection.confidence}\n`;
+
+    // Repo Section
+    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)}`;
+    } catch {}
+
+    console.log(UI.box(content, `${UI.logo()} Status`));
+  });
+
+// ── omnitype daemon ─────────────────────────────────────────────────────────
+program
+  .command('daemon')
+  .description('Watch a directory and track provenance in real time')
+  .option('-p, --path <dir>',     'Directory to watch (default: cwd)', process.cwd())
+  .option('-n, --project <name>', 'Project name (default: directory name)')
+  .option('-b, --branch <name>',  'Branch name (default: detected from git)')
+  .action((opts) => {
+    const watchPath   = path.resolve(opts.path ?? process.cwd());
+    const projectName = opts.project ?? path.basename(watchPath);
+    
+    UI.info(`Starting OmniType Sentinel for ${UI.bold(projectName)}...`);
+    UI.dim(`Watching: ${watchPath}`);
+    
+    startDaemon({ watchPath, projectName, branch: opts.branch });
+  });
+
+// ── omnitype hooks ──────────────────────────────────────────────────────────
+program
+  .command('hooks')
+  .description('Manage git hooks for commit-level provenance tracking')
+  .addCommand(
+    new Command('install')
+      .description('Install post-commit hook in the current repo')
+      .option('--repo <path>', 'Repo path', process.cwd())
+      .action((opts) => {
+        try { 
+          installHooks(opts.repo);
+          UI.success('Git hooks installed successfully.');
+        } catch (err) { 
+          UI.error(String(err)); 
+          process.exit(1); 
+        }
+      })
+  )
+  .addCommand(
+    new Command('uninstall')
+      .description('Remove omnitype hook from post-commit')
+      .option('--repo <path>', 'Repo path', process.cwd())
+      .action((opts) => {
+        try { 
+          uninstallHooks(opts.repo);
+          UI.success('Git hooks removed.');
+        } catch (err) { 
+          UI.error(String(err)); 
+          process.exit(1); 
+        }
+      })
+  );
+
+// ── omnitype blame ──────────────────────────────────────────────────────────
+program
+  .command('blame <file>')
+  .description('Enhanced git blame with AI/model attribution overlay')
+  .option('--no-color',    'Disable color output')
+  .option('--stats',       'Show attribution summary after blame output')
+  .option('--repo <path>', 'Repo root path (default: auto-detected)')
+  .action(async (file, opts) => {
+    await runBlame({ file, repoPath: opts.repo, noColor: !opts.color, showStats: opts.stats });
+  });
+
+// ── omnitype notes fetch/push ───────────────────────────────────────────────
+program
+  .command('notes')
+  .description('Sync git notes with remote')
+  .addCommand(
+    new Command('fetch')
+      .description('Fetch attribution notes from remote')
+      .option('--remote <name>', 'Remote name', 'origin')
+      .option('--repo <path>', 'Repo path', process.cwd())
+      .action(async (opts) => {
+        const spinner = UI.spinner(`Fetching notes from ${opts.remote}...`);
+        try {
+          await fetchNotes(opts.repo, opts.remote);
+          spinner.succeed('Notes fetched.');
+        } catch (err) {
+          spinner.fail('Fetch failed');
+          UI.error(String(err));
+        }
+      })
+  )
+  .addCommand(
+    new Command('push')
+      .description('Push attribution notes to remote')
+      .option('--remote <name>', 'Remote name', 'origin')
+      .option('--repo <path>', 'Repo path', process.cwd())
+      .action(async (opts) => {
+        const spinner = UI.spinner(`Pushing notes to ${opts.remote}...`);
+        try {
+          await pushNotes(opts.repo, opts.remote);
+          spinner.succeed('Notes pushed.');
+        } catch (err) {
+          spinner.fail('Push failed');
+          UI.error(String(err));
+        }
+      })
+  );
+
+// ── omnitype commit-scan ────────────────────────────────────────────────────
+program
+  .command('commit-scan')
+  .description('Scan the latest commit and push provenance (called by git hook)')
+  .option('--repo <path>', 'Repo path', process.cwd())
+  .action(async (opts) => {
+    try {
+      await commitScan(path.resolve(opts.repo));
+    } catch (err) {
+      UI.error(String(err));
+    }
+  });
+
+// ── omnitype setup-claude-hook ──────────────────────────────────────────────
+program
+  .command('setup-claude-hook')
+  .description('Install OmniType model-detection hook into ~/.claude/settings.json')
+  .option('--print', 'Print the hook JSON instead of writing it')
+  .action((opts) => {
+    const cfgPath = path.join(os.homedir(), '.claude', 'settings.json');
+    const hookEntry = {
+      matcher: 'Write|Edit|MultiEdit|NotebookEdit',
+      hooks: [{
+        type: 'command',
+        command: `node -e "const fs=require('fs'),os=require('os'),p=require('path');const d=p.join(os.homedir(),'.omnitype');fs.mkdirSync(d,{recursive:true});let m=process.env.CLAUDE_MODEL||process.env.ANTHROPIC_MODEL;if(!m){try{const s=JSON.parse(fs.readFileSync(p.join(os.homedir(),'.claude','settings.json'),'utf8'));m=s.model||s.defaultModel;}catch{}}fs.writeFileSync(p.join(d,'active-model.json'),JSON.stringify({model:m||'claude-sonnet-4-6',tool:'claude-code',ts:Date.now()}))"`,
+      }],
+    };
+
+    if (opts.print) {
+      console.log(JSON.stringify({ hooks: { PreToolUse: [hookEntry] } }, null, 2));
+      return;
+    }
+
+    let settings: Record<string, any> = {};
+    try { settings = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch {}
+    settings.hooks = settings.hooks ?? {};
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse ?? [];
+
+    const already = (settings.hooks.PreToolUse as any[]).some(
+      (h: any) => typeof h?.hooks?.[0]?.command === 'string' && h.hooks[0].command.includes('.omnitype')
+    );
+    if (already) {
+      UI.info('OmniType hook is already installed in ~/.claude/settings.json');
+      return;
+    }
+
+    settings.hooks.PreToolUse.push(hookEntry);
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, JSON.stringify(settings, null, 2));
+    UI.success('OmniType hook installed in ~/.claude/settings.json');
+    UI.info('Claude Code will now report its model on every file edit.');
+  });
+
+// ── omnitype setup-vscode-hook ──────────────────────────────────────────────
+/**
+ * VS Code and every fork (Cursor, Windsurf, Antigravity, PearAI, Void, Zed…)
+ * share the same User settings.json path. They also all support a
+ * "runOnSave"-style task via the built-in task runner AND they all support
+ * the `terminal.integrated.env.*` setting to inject env vars.
+ *
+ * The most reliable universal hook is writing a VS Code keybinding-free
+ * globalTask using the `runOn: default` flag — but that only fires on folder
+ * open. Instead we write a compact snippet into the User settings.json that
+ * registers a shell command via the `emeraldwalk.runonsave`-compatible
+ * `omnitype.signal` approach using VS Code's native `tasks` global config.
+ *
+ * Simpler and actually universal: write a one-liner into the fork's
+ * User/settings.json under `terminal.integrated.env` is NOT right either.
+ *
+ * The REAL universal answer: write the OmniType signal command into the
+ * fork's global keybindings OR — even simpler — write a `.vscode/tasks.json`
+ * that the user can invoke. But the most frictionless path is to write
+ * into the fork's User/settings.json the `files.saveParticipants` equivalent.
+ *
+ * After research: the only truly hook-based, no-extension-required mechanism
+ * that works across ALL VS Code forks is writing a global User task with
+ * `"runOn": "folderOpen"` plus a file watcher script. But that fires once.
+ *
+ * The correct answer: write a sentinel-refresh shell script that the fork
+ * launches on startup via `terminal.integrated.shellIntegration.enabled` +
+ * a `.profile`/`shellrc` entry — but that's invasive.
+ *
+ * REAL correct answer: the OmniType VS Code extension IS the universal hook.
+ * This command installs it into every detected VS Code fork via their CLI.
+ * For forks without a CLI, it prints the VSIX install path.
+ */
+program
+  .command('setup-vscode-hook')
+  .description('Install OmniType into every detected VS Code fork (Cursor, Windsurf, Antigravity, etc.)')
+  .option('--fork <name>', 'Target a specific fork by name (e.g. cursor, windsurf, antigravity)')
+  .option('--print',       'Print install commands without running them')
+  .action(async (opts) => {
+    // Known VS Code fork CLI binaries → display name + settings path segment
+    const FORKS: Array<{ cli: string; name: string; dir: string }> = [
+      { cli: 'code',         name: 'VS Code',      dir: 'Code' },
+      { cli: 'cursor',       name: 'Cursor',        dir: 'Cursor' },
+      { cli: 'windsurf',     name: 'Windsurf',      dir: 'Windsurf' },
+      { cli: 'antigravity',  name: 'Antigravity',   dir: 'Antigravity' },
+      { cli: 'pearai',       name: 'PearAI',        dir: 'PearAI' },
+      { cli: 'void',         name: 'Void',          dir: 'Void' },
+      { cli: 'trae',         name: 'Trae',          dir: 'Trae' },
+    ];
+
+    const { execSync } = require('child_process');
+
+    function hasCli(binary: string): boolean {
+      try { execSync(`which ${binary} 2>/dev/null || where ${binary} 2>nul`, { stdio: 'pipe' }); return true; }
+      catch { return false; }
+    }
+
+    function settingsPath(dir: string): string {
+      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');
+      }
+    }
+
+    // The sentinel snippet written into settings.json.
+    // Uses VS Code's `terminal.integrated.env` to inject OMNITYPE_TOOL so the
+    // fork's own terminal sessions know which tool to signal. More importantly,
+    // writes a task definition the user can run — but the real value is that
+    // OmniType's VS Code extension auto-detects the fork and handles attribution.
+    // The settings entry below also sets `omnitype.enabled: true` which the
+    // OmniType extension reads to confirm the user has explicitly opted in.
+    const SETTINGS_SNIPPET: Record<string, unknown> = {
+      'omnitype.enabled': true,
+      'omnitype.autoSignal': true,
+    };
+
+    const targets = opts.fork
+      ? FORKS.filter(f => f.cli === opts.fork || f.name.toLowerCase() === opts.fork.toLowerCase())
+      : FORKS;
+
+    const detected: typeof FORKS = [];
+    const missing:  typeof FORKS = [];
+
+    for (const fork of targets) {
+      if (hasCli(fork.cli)) detected.push(fork);
+      else {
+        // Also check if the settings file exists even without a CLI
+        const sp = settingsPath(fork.dir);
+        if (fs.existsSync(sp)) detected.push(fork);
+        else missing.push(fork);
+      }
+    }
+
+    if (detected.length === 0) {
+      UI.info('No supported VS Code forks detected. Install one of: ' +
+        FORKS.map(f => f.cli).join(', '));
+      return;
+    }
+
+    let anyInstalled = false;
+    for (const fork of detected) {
+      const sp = settingsPath(fork.dir);
+
+      // Merge settings snippet
+      let settings: Record<string, any> = {};
+      try { settings = JSON.parse(fs.readFileSync(sp, 'utf8')); } catch {}
+
+      const alreadyEnabled = settings['omnitype.enabled'] === true;
+      if (alreadyEnabled) {
+        UI.info(`${fork.name}: OmniType already enabled.`);
+        continue;
+      }
+
+      if (opts.print) {
+        console.log(`\n# ${fork.name} (${sp})`);
+        console.log(JSON.stringify(SETTINGS_SNIPPET, null, 2));
+        continue;
+      }
+
+      Object.assign(settings, SETTINGS_SNIPPET);
+      fs.mkdirSync(path.dirname(sp), { recursive: true });
+      fs.writeFileSync(sp, JSON.stringify(settings, null, 2));
+      UI.success(`${fork.name}: OmniType enabled in settings.json`);
+
+      // Also try CLI extension install if available
+      if (hasCli(fork.cli)) {
+        try {
+          execSync(`${fork.cli} --install-extension omnitype.omnitype-vscode --force 2>/dev/null`, { stdio: 'pipe' });
+          UI.success(`${fork.name}: Extension installed via ${fork.cli} CLI`);
+        } catch {
+          UI.dim(`${fork.name}: Install manually: ${fork.cli} --install-extension omnitype.omnitype-vscode`);
+        }
+      }
+      anyInstalled = true;
+    }
+
+    if (anyInstalled) {
+      console.log('');
+      UI.success('OmniType is now active in your VS Code fork(s).');
+      UI.info('Every AI edit will be attributed automatically — no restart needed.');
+    }
+
+    if (missing.length > 0 && !opts.fork) {
+      UI.dim(`Not detected: ${missing.map(f => f.name).join(', ')}`);
+    }
+  });
+
+// ── omnitype signal ──────────────────────────────────────────────────────────
+program
+  .command('signal')
+  .description('Report the active AI model to the OmniType sentinel')
+  .requiredOption('-m, --model <name>', 'Model name (e.g., gpt-4o, claude-3-5-sonnet)')
+  .option('-t, --tool <name>',  'Tool name (e.g., aider, continue, my-script)', 'cli-signal')
+  .option('--ts <ms>',          'Override timestamp (Unix ms)')
+  .action((opts) => {
+    const dir = path.join(os.homedir(), '.omnitype');
+    fs.mkdirSync(dir, { recursive: true });
+    const payload = {
+      model: opts.model,
+      tool:  opts.tool,
+      ts:    opts.ts ? parseInt(opts.ts) : Date.now(),
+    };
+    fs.writeFileSync(path.join(dir, 'active-model.json'), JSON.stringify(payload));
+    UI.success(`Signalled ${UI.bold(opts.model)} via ${opts.tool}`);
+  });
+
+// ── omnitype whoami ──────────────────────────────────────────────────────────
+program
+  .command('whoami')
+  .description('Show logged-in user info')
+  .action(async () => {
+    const api = new ApiClient();
+    if (!api.isSignedIn) {
+      UI.error('Not signed in. Run: omnitype login');
+      process.exit(1);
+    }
+    const spinner = UI.spinner('Fetching profile…');
+    try {
+      const profile = await api.getProfile();
+      spinner.stop();
+      let content = '';
+      content += `  ${chalk.bold('Username:')}  ${chalk.hex(COLORS.primary)(profile.username ?? api.username)}\n`;
+      if (profile.email)      content += `  ${chalk.bold('Email:')}     ${chalk.white(profile.email)}\n`;
+      if (profile.full_name)  content += `  ${chalk.bold('Name:')}      ${chalk.white(profile.full_name)}\n`;
+      if (profile.created_at) content += `  ${chalk.bold('Member:')}    ${UI.dim(new Date(profile.created_at).toLocaleDateString())}\n`;
+      console.log(UI.box(content, `${UI.logo()} — whoami`));
+    } catch (e: any) {
+      spinner.stop();
+      UI.error(e.message);
+      process.exit(1);
+    }
+  });
+
+// ── omnitype stats ───────────────────────────────────────────────────────────
+program
+  .command('stats')
+  .description('Show your personal provenance stats across all projects')
+  .option('-n, --top <n>', 'Show top N projects', '10')
+  .action(async (opts) => {
+    const api = new ApiClient();
+    if (!api.isSignedIn) {
+      UI.error('Not signed in. Run: omnitype login');
+      process.exit(1);
+    }
+    const spinner = UI.spinner('Fetching stats…');
+    try {
+      const projects: any[] = await api.getPersonalStats();
+      spinner.stop();
+
+      if (!projects.length) {
+        UI.info('No provenance data yet. Run the daemon or push some commits.');
+        return;
+      }
+
+      const topN = parseInt(opts.top, 10);
+      const sorted = [...projects].sort((a, b) => (b.total_chars ?? 0) - (a.total_chars ?? 0)).slice(0, topN);
+
+      // Totals across all projects
+      const totals = projects.reduce((acc, p) => {
+        acc.ai    += p.ai_chars    ?? 0;
+        acc.user  += p.user_chars  ?? 0;
+        acc.paste += p.paste_chars ?? 0;
+        acc.total += p.total_chars ?? 0;
+        return acc;
+      }, { ai: 0, user: 0, paste: 0, total: 0 });
+
+      let content = '';
+      content += `  ${chalk.bold('Total projects:')}  ${chalk.white(projects.length)}\n`;
+      content += `  ${chalk.bold('Total chars:')}     ${chalk.white(totals.total.toLocaleString())}\n`;
+      content += `\n`;
+      content += `  ${UI.label('AI', COLORS.ai)}    ${UI.bar(totals.ai, totals.total, 16, COLORS.ai)}  ${UI.pct(totals.ai, totals.total)}\n`;
+      content += `  ${UI.label('You', COLORS.user)}   ${UI.bar(totals.user, totals.total, 16, COLORS.user)}  ${UI.pct(totals.user, totals.total)}\n`;
+      content += `  ${UI.label('Paste', COLORS.paste)} ${UI.bar(totals.paste, totals.total, 16, COLORS.paste)}  ${UI.pct(totals.paste, totals.total)}\n`;
+      content += `\n  ${chalk.bold(`Top ${topN} projects:`)}\n`;
+
+      for (const p of sorted) {
+        const name  = chalk.hex(COLORS.primary)(p.project_name.padEnd(24));
+        const aiPct = UI.pct(p.ai_chars ?? 0, p.total_chars ?? 1);
+        const bar   = UI.bar(p.ai_chars ?? 0, p.total_chars ?? 1, 12, COLORS.ai);
+        const files = UI.dim(`${p.file_count ?? 0}f`);
+        content += `  ${name} ${bar} ${aiPct}  ${files}\n`;
+
+        // Model breakdown if available
+        if (p.model_breakdown && Object.keys(p.model_breakdown).length) {
+          const top = Object.entries(p.model_breakdown as Record<string, number>)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 2)
+            .map(([m, c]) => `${chalk.hex(COLORS.secondary)(m)} ${UI.dim(c.toLocaleString())}`)
+            .join('  ');
+          content += `  ${' '.repeat(26)}${top}\n`;
+        }
+      }
+
+      console.log(UI.box(content, `${UI.logo()} Stats`));
+    } catch (e: any) {
+      spinner.stop();
+      UI.error(e.message);
+      process.exit(1);
+    }
+  });
+
+program.parseAsync(process.argv);

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}