@omnitype-code/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ApiClient_1 = require("./core/ApiClient");
+const ModelDetector_1 = require("./core/ModelDetector");
+const hooks_1 = require("./hooks");
+const daemon_1 = require("./daemon");
+const blame_1 = require("./blame");
+const GitNotes_1 = require("./core/GitNotes");
+const UI_1 = require("./core/UI");
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+const program = new commander_1.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_1.UI.banner());
+    const api = new ApiClient_1.ApiClient();
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email address:',
+            when: !opts.email,
+            validate: (input) => 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_1.UI.spinner('Authenticating with OmniType Cloud...');
+    try {
+        const username = await api.login(email, password);
+        spinner.succeed(`Welcome back, ${UI_1.UI.bold(username)}!`);
+        UI_1.UI.success('You are now signed in.');
+    }
+    catch (err) {
+        spinner.fail('Authentication failed');
+        UI_1.UI.error(err.message || String(err));
+        process.exit(1);
+    }
+});
+// ── omnitype logout ─────────────────────────────────────────────────────────
+program
+    .command('logout')
+    .description('Sign out')
+    .action(() => {
+    new ApiClient_1.ApiClient().logout();
+    UI_1.UI.success('Signed out successfully.');
+});
+// ── omnitype status ─────────────────────────────────────────────────────────
+program
+    .command('status')
+    .description('Show current auth and model detection status')
+    .action(() => {
+    const api = new ApiClient_1.ApiClient();
+    const detection = new ModelDetector_1.ModelDetector().detect();
+    let content = '';
+    // Account Section
+    if (api.isSignedIn) {
+        content += `${chalk_1.default.bold('Account:')}  ${chalk_1.default.cyan(api.username)}\n`;
+        content += `${chalk_1.default.bold('Server:')}   ${UI_1.UI.dim(api.apiUrl)}\n`;
+    }
+    else {
+        content += `${chalk_1.default.bold('Account:')}  ${chalk_1.default.red('Not signed in')} ${UI_1.UI.dim('(run: omnitype login)')}\n`;
+    }
+    content += `\n`;
+    // Detection Section
+    content += `${chalk_1.default.bold('Current Context:')}\n`;
+    const modelColor = detection.model.includes('claude') ? '#D97757' : (detection.model.includes('gpt') ? '#10A37F' : UI_1.COLORS.ai);
+    content += `  ${chalk_1.default.bold('Model:')}  ${chalk_1.default.hex(modelColor)(detection.model)}\n`;
+    content += `  ${chalk_1.default.bold('Tool:')}   ${chalk_1.default.white(detection.tool)}\n`;
+    const confColors = {
+        deterministic: chalk_1.default.green('Deterministic'),
+        high: chalk_1.default.green('High'),
+        medium: chalk_1.default.yellow('Medium'),
+        low: chalk_1.default.red('Low'),
+    };
+    content += `  ${chalk_1.default.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_1.default.bold('Repository:')}\n`;
+        content += `  ${chalk_1.default.bold('Project:')} ${gitRepo}\n`;
+        content += `  ${chalk_1.default.bold('Branch:')}  ${chalk_1.default.magenta(gitBranch)}`;
+    }
+    catch { }
+    console.log(UI_1.UI.box(content, `${UI_1.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_1.UI.info(`Starting OmniType Sentinel for ${UI_1.UI.bold(projectName)}...`);
+    UI_1.UI.dim(`Watching: ${watchPath}`);
+    (0, daemon_1.startDaemon)({ watchPath, projectName, branch: opts.branch });
+});
+// ── omnitype hooks ──────────────────────────────────────────────────────────
+program
+    .command('hooks')
+    .description('Manage git hooks for commit-level provenance tracking')
+    .addCommand(new commander_1.Command('install')
+    .description('Install post-commit hook in the current repo')
+    .option('--repo <path>', 'Repo path', process.cwd())
+    .action((opts) => {
+    try {
+        (0, hooks_1.installHooks)(opts.repo);
+        UI_1.UI.success('Git hooks installed successfully.');
+    }
+    catch (err) {
+        UI_1.UI.error(String(err));
+        process.exit(1);
+    }
+}))
+    .addCommand(new commander_1.Command('uninstall')
+    .description('Remove omnitype hook from post-commit')
+    .option('--repo <path>', 'Repo path', process.cwd())
+    .action((opts) => {
+    try {
+        (0, hooks_1.uninstallHooks)(opts.repo);
+        UI_1.UI.success('Git hooks removed.');
+    }
+    catch (err) {
+        UI_1.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 (0, blame_1.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 commander_1.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_1.UI.spinner(`Fetching notes from ${opts.remote}...`);
+    try {
+        await (0, GitNotes_1.fetchNotes)(opts.repo, opts.remote);
+        spinner.succeed('Notes fetched.');
+    }
+    catch (err) {
+        spinner.fail('Fetch failed');
+        UI_1.UI.error(String(err));
+    }
+}))
+    .addCommand(new commander_1.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_1.UI.spinner(`Pushing notes to ${opts.remote}...`);
+    try {
+        await (0, GitNotes_1.pushNotes)(opts.repo, opts.remote);
+        spinner.succeed('Notes pushed.');
+    }
+    catch (err) {
+        spinner.fail('Push failed');
+        UI_1.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 (0, hooks_1.commitScan)(path.resolve(opts.repo));
+    }
+    catch (err) {
+        UI_1.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 = {};
+    try {
+        settings = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    }
+    catch { }
+    settings.hooks = settings.hooks ?? {};
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse ?? [];
+    const already = settings.hooks.PreToolUse.some((h) => typeof h?.hooks?.[0]?.command === 'string' && h.hooks[0].command.includes('.omnitype'));
+    if (already) {
+        UI_1.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_1.UI.success('OmniType hook installed in ~/.claude/settings.json');
+    UI_1.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 = [
+        { 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) {
+        try {
+            execSync(`which ${binary} 2>/dev/null || where ${binary} 2>nul`, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function settingsPath(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');
+        }
+    }
+    // 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 = {
+        '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 = [];
+    const missing = [];
+    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_1.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 = {};
+        try {
+            settings = JSON.parse(fs.readFileSync(sp, 'utf8'));
+        }
+        catch { }
+        const alreadyEnabled = settings['omnitype.enabled'] === true;
+        if (alreadyEnabled) {
+            UI_1.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_1.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_1.UI.success(`${fork.name}: Extension installed via ${fork.cli} CLI`);
+            }
+            catch {
+                UI_1.UI.dim(`${fork.name}: Install manually: ${fork.cli} --install-extension omnitype.omnitype-vscode`);
+            }
+        }
+        anyInstalled = true;
+    }
+    if (anyInstalled) {
+        console.log('');
+        UI_1.UI.success('OmniType is now active in your VS Code fork(s).');
+        UI_1.UI.info('Every AI edit will be attributed automatically — no restart needed.');
+    }
+    if (missing.length > 0 && !opts.fork) {
+        UI_1.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_1.UI.success(`Signalled ${UI_1.UI.bold(opts.model)} via ${opts.tool}`);
+});
+// ── omnitype whoami ──────────────────────────────────────────────────────────
+program
+    .command('whoami')
+    .description('Show logged-in user info')
+    .action(async () => {
+    const api = new ApiClient_1.ApiClient();
+    if (!api.isSignedIn) {
+        UI_1.UI.error('Not signed in. Run: omnitype login');
+        process.exit(1);
+    }
+    const spinner = UI_1.UI.spinner('Fetching profile…');
+    try {
+        const profile = await api.getProfile();
+        spinner.stop();
+        let content = '';
+        content += `  ${chalk_1.default.bold('Username:')}  ${chalk_1.default.hex(UI_1.COLORS.primary)(profile.username ?? api.username)}\n`;
+        if (profile.email)
+            content += `  ${chalk_1.default.bold('Email:')}     ${chalk_1.default.white(profile.email)}\n`;
+        if (profile.full_name)
+            content += `  ${chalk_1.default.bold('Name:')}      ${chalk_1.default.white(profile.full_name)}\n`;
+        if (profile.created_at)
+            content += `  ${chalk_1.default.bold('Member:')}    ${UI_1.UI.dim(new Date(profile.created_at).toLocaleDateString())}\n`;
+        console.log(UI_1.UI.box(content, `${UI_1.UI.logo()} — whoami`));
+    }
+    catch (e) {
+        spinner.stop();
+        UI_1.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_1.ApiClient();
+    if (!api.isSignedIn) {
+        UI_1.UI.error('Not signed in. Run: omnitype login');
+        process.exit(1);
+    }
+    const spinner = UI_1.UI.spinner('Fetching stats…');
+    try {
+        const projects = await api.getPersonalStats();
+        spinner.stop();
+        if (!projects.length) {
+            UI_1.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_1.default.bold('Total projects:')}  ${chalk_1.default.white(projects.length)}\n`;
+        content += `  ${chalk_1.default.bold('Total chars:')}     ${chalk_1.default.white(totals.total.toLocaleString())}\n`;
+        content += `\n`;
+        content += `  ${UI_1.UI.label('AI', UI_1.COLORS.ai)}    ${UI_1.UI.bar(totals.ai, totals.total, 16, UI_1.COLORS.ai)}  ${UI_1.UI.pct(totals.ai, totals.total)}\n`;
+        content += `  ${UI_1.UI.label('You', UI_1.COLORS.user)}   ${UI_1.UI.bar(totals.user, totals.total, 16, UI_1.COLORS.user)}  ${UI_1.UI.pct(totals.user, totals.total)}\n`;
+        content += `  ${UI_1.UI.label('Paste', UI_1.COLORS.paste)} ${UI_1.UI.bar(totals.paste, totals.total, 16, UI_1.COLORS.paste)}  ${UI_1.UI.pct(totals.paste, totals.total)}\n`;
+        content += `\n  ${chalk_1.default.bold(`Top ${topN} projects:`)}\n`;
+        for (const p of sorted) {
+            const name = chalk_1.default.hex(UI_1.COLORS.primary)(p.project_name.padEnd(24));
+            const aiPct = UI_1.UI.pct(p.ai_chars ?? 0, p.total_chars ?? 1);
+            const bar = UI_1.UI.bar(p.ai_chars ?? 0, p.total_chars ?? 1, 12, UI_1.COLORS.ai);
+            const files = UI_1.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)
+                    .sort(([, a], [, b]) => b - a)
+                    .slice(0, 2)
+                    .map(([m, c]) => `${chalk_1.default.hex(UI_1.COLORS.secondary)(m)} ${UI_1.UI.dim(c.toLocaleString())}`)
+                    .join('  ');
+                content += `  ${' '.repeat(26)}${top}\n`;
+            }
+        }
+        console.log(UI_1.UI.box(content, `${UI_1.UI.logo()} Stats`));
+    }
+    catch (e) {
+        spinner.stop();
+        UI_1.UI.error(e.message);
+        process.exit(1);
+    }
+});
+program.parseAsync(process.argv);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@omnitype-code/cli",
+  "version": "0.1.0",
+  "description": "OmniType CLI — editor-agnostic code provenance tracking",
+  "bin": {
+    "omnitype": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.6.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^8.2.7",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/gradient-string": "^1.1.6",
+    "@types/inquirer": "^8.2.12",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}