@omnitype-code/cli 0.1.0

package/src/blame.ts

@@ -0,0 +1,240 @@
+import { execFileSync } from 'child_process';
+import * as path from 'path';
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+import { COLORS, UI } from './core/UI';
+import { resolveFileLinesAsync, getCurrentBranch, findRepoRoot as resolverFindRoot } from './core/ProvenanceResolver';
+import type { Origin, LineInfo } from './core/ProvenanceResolver';
+
+const ORIGIN_COLOR: Record<Origin, string> = {
+  ai:       COLORS.ai,
+  user:     COLORS.user,
+  paste:    COLORS.paste,
+  existing: '#444444',
+};
+
+const ORIGIN_BG: Record<Origin, string> = {
+  ai:       '#3d0070',
+  user:     '#003d6b',
+  paste:    '#4a3000',
+  existing: '#1a1a1a',
+};
+
+const ORIGIN_BADGE: Record<Origin, string> = {
+  ai:       ' AI ',
+  user:     'USR ',
+  paste:    'PST ',
+  existing: 'SRC ',
+};
+
+function badge(origin: Origin, useColor: boolean): string {
+  if (!useColor) return `[${ORIGIN_BADGE[origin].trim()}]`;
+  return chalk.bgHex(ORIGIN_BG[origin]).hex(ORIGIN_COLOR[origin]).bold(ORIGIN_BADGE[origin]);
+}
+
+function shortModel(model: string): string {
+  return model
+    .replace(/claude-(\w+)-(\d+)-(\d+).*/, 'c-$1')
+    .replace(/gpt-(\w+)/, 'gpt-$1')
+    .replace(/gemini-(\w+)/, 'gem-$1')
+    .substring(0, 12);
+}
+
+function shortTool(tool: string): string {
+  return tool
+    .replace('claude-code', 'claude')
+    .replace('antigravity', 'ag')
+    .substring(0, 10);
+}
+
+function attrTag(info: LineInfo | undefined, useColor: boolean): string {
+  if (!info || info.origin === 'existing') return useColor ? chalk.hex('#333333')('──────────────') : '              ';
+  const parts: string[] = [];
+  if (info.model) parts.push(shortModel(info.model));
+  if (info.tool && info.tool !== 'unknown') parts.push(shortTool(info.tool));
+  const tag = parts.join(chalk.hex('#555555')('·'));
+  return useColor ? chalk.hex(ORIGIN_COLOR[info.origin])(tag.padEnd(14)) : tag.padEnd(14);
+}
+
+function barLine(label: string, count: number, total: number, color: string, width = 24): string {
+  const pct   = total === 0 ? 0 : count / total;
+  const filled = Math.round(pct * width);
+  const bar   = chalk.hex(color)('█'.repeat(filled)) + chalk.hex('#222222')('█'.repeat(width - filled));
+  const pctStr = chalk.hex(color).bold(`${Math.round(pct * 100)}%`.padStart(4));
+  const countStr = chalk.hex('#555555')(`${count} lines`.padStart(10));
+  return `  ${chalk.hex(color).bold(label.padEnd(8))}  ${bar}  ${pctStr}  ${countStr}`;
+}
+
+export interface BlameOptions {
+  file: string;
+  repoPath?: string;
+  noColor?: boolean;
+  showStats?: boolean;
+}
+
+export async function runBlame(opts: BlameOptions): Promise<void> {
+  const filePath    = path.resolve(opts.file);
+  const repoPath    = opts.repoPath ?? findRepoRoot(filePath) ?? process.cwd();
+  const relPath     = path.relative(repoPath, filePath).replace(/\\/g, '/');
+  const useColor    = !opts.noColor && process.stdout.isTTY;
+  const branch      = getCurrentBranch(repoPath);
+  const projectName = detectProjectName(repoPath);
+
+  // ── Header ─────────────────────────────────────────────────────────────────
+  if (useColor) {
+    const g = (s: string) => gradient([COLORS.primary, COLORS.secondary, COLORS.ai])(s);
+    process.stdout.write('\n');
+    process.stdout.write(chalk.bold(g('  ◈ OmniType')) + chalk.hex('#444444')(' │ ') + chalk.hex('#888888')('code provenance') + '\n');
+    process.stdout.write(chalk.hex('#333333')('  ─────────────────────────────────────────────────────────────') + '\n');
+    process.stdout.write(chalk.hex('#555555')('  ◎ ') + chalk.hex('#cccccc').bold(path.basename(filePath)) + chalk.hex('#444444')(` · ${relPath}`) + '\n');
+    process.stdout.write(chalk.hex('#555555')('  ⎇ ') + chalk.hex('#58a6ff')(branch) + chalk.hex('#444444')(` · ${projectName}`) + '\n');
+    process.stdout.write(chalk.hex('#333333')('  ─────────────────────────────────────────────────────────────') + '\n\n');
+  }
+
+  let blameOut: string;
+  try {
+    blameOut = execFileSync(
+      'git', ['-C', repoPath, 'blame', '--line-porcelain', filePath],
+      { encoding: 'utf8' }
+    );
+  } catch (err) {
+    UI.error(`Git blame failed: ${err}`);
+    process.exit(1);
+  }
+
+  const lineMap    = await resolveFileLinesAsync(repoPath, relPath, filePath, branch, projectName);
+  const blameLines = parsePorcelainBlame(blameOut);
+
+  const stats: Record<Origin | 'total', number> = { ai: 0, user: 0, paste: 0, existing: 0, total: 0 };
+  const modelCounts: Record<string, number> = {};
+  const toolCounts:  Record<string, number> = {};
+
+  for (const bl of blameLines) {
+    const info   = lineMap.get(bl.lineNum);
+    const origin = info?.origin ?? 'existing';
+
+    const sha    = useColor ? chalk.hex('#333333')(bl.shortSha) : bl.shortSha;
+    const author = useColor ? chalk.hex('#555555')(bl.author.slice(0, 9).padEnd(9)) : bl.author.slice(0, 9).padEnd(9);
+    const lineNo = useColor ? chalk.hex('#444444')(bl.lineNum.toString().padStart(4)) : bl.lineNum.toString().padStart(4);
+    const bdg    = badge(origin, useColor);
+    const tag    = attrTag(info, useColor);
+    const sep    = useColor ? chalk.hex(ORIGIN_COLOR[origin])('▏') : '|';
+    const code   = origin === 'existing'
+      ? (useColor ? chalk.hex('#555555')(bl.content) : bl.content)
+      : bl.content;
+
+    process.stdout.write(`${sha} ${author} ${lineNo}  ${bdg} ${tag} ${sep} ${code}\n`);
+
+    stats[origin]++;
+    stats.total++;
+    if (origin === 'ai') {
+      if (info?.model) modelCounts[info.model] = (modelCounts[info.model] ?? 0) + 1;
+      if (info?.tool)  toolCounts[info.tool]   = (toolCounts[info.tool]   ?? 0) + 1;
+    }
+  }
+
+  if (!opts.showStats || blameLines.length === 0) return;
+
+  // ── Stats footer ───────────────────────────────────────────────────────────
+  const T = stats.total;
+  const lines: string[] = [''];
+
+  // Branding
+  if (useColor) {
+    const g = (s: string) => gradient([COLORS.primary, COLORS.secondary, COLORS.ai])(s);
+    lines.push('  ' + chalk.bold(g('◈ OmniType')) + chalk.hex('#333333')(' · Attribution Report'));
+    lines.push('  ' + chalk.hex('#333333')('─'.repeat(52)));
+  } else {
+    lines.push('  OmniType · Attribution Report');
+    lines.push('  ' + '─'.repeat(52));
+  }
+
+  lines.push('');
+  lines.push(barLine('AI',      stats.ai,       T, COLORS.ai));
+  lines.push(barLine('Typed',   stats.user,     T, COLORS.user));
+  lines.push(barLine('Pasted',  stats.paste,    T, COLORS.paste));
+  lines.push(barLine('Source',  stats.existing, T, '#444444'));
+  lines.push('');
+
+  if (Object.keys(modelCounts).length > 0) {
+    lines.push('  ' + chalk.hex('#555555').bold('MODELS'));
+    for (const [m, count] of Object.entries(modelCounts).sort(([, a], [, b]) => b - a)) {
+      const pct = Math.round(count / T * 100);
+      lines.push(`    ${chalk.hex(COLORS.ai)(m.padEnd(28))} ${chalk.hex(COLORS.ai).bold(`${pct}%`.padStart(4))}  ${chalk.hex('#444444')(`${count} lines`)}`);
+    }
+    lines.push('');
+  }
+
+  if (Object.keys(toolCounts).length > 0) {
+    lines.push('  ' + chalk.hex('#555555').bold('TOOLS'));
+    for (const [t, count] of Object.entries(toolCounts).sort(([, a], [, b]) => b - a)) {
+      const pct = Math.round(count / T * 100);
+      lines.push(`    ${chalk.hex(COLORS.primary)(t.padEnd(28))} ${chalk.hex(COLORS.primary).bold(`${pct}%`.padStart(4))}  ${chalk.hex('#444444')(`${count} lines`)}`);
+    }
+    lines.push('');
+  }
+
+  process.stdout.write(lines.join('\n') + '\n');
+}
+
+// ── Porcelain blame parser ────────────────────────────────────────────────────
+
+interface BlameLine {
+  lineNum:  number;
+  shortSha: string;
+  author:   string;
+  date:     string;
+  content:  string;
+}
+
+function parsePorcelainBlame(raw: string): BlameLine[] {
+  const lines  = raw.split('\n');
+  const result: BlameLine[] = [];
+  const cache  = new Map<string, { author: string; date: string }>();
+
+  let i = 0;
+  while (i < lines.length) {
+    const header = lines[i];
+    if (!header || header.length < 40) { i++; continue; }
+
+    const sha     = header.slice(0, 40);
+    const parts   = header.split(' ');
+    const lineNum = parseInt(parts[2] ?? parts[1], 10);
+    if (isNaN(lineNum)) { i++; continue; }
+
+    let author = cache.get(sha)?.author ?? '';
+    let date   = cache.get(sha)?.date   ?? '';
+
+    i++;
+    while (i < lines.length && !lines[i].startsWith('\t')) {
+      const l = lines[i];
+      if (l.startsWith('author ') && !author)   author = l.slice(7).trim();
+      if (l.startsWith('author-time ') && !date) {
+        date = new Date(parseInt(l.slice(12), 10) * 1000).toISOString().slice(0, 10);
+      }
+      i++;
+    }
+
+    if (!cache.has(sha)) cache.set(sha, { author, date });
+    const content = (lines[i] ?? '').slice(1);
+    i++;
+
+    result.push({ lineNum, shortSha: sha.slice(0, 7), author, date, content });
+  }
+
+  return result;
+}
+
+function findRepoRoot(startPath: string): string | undefined {
+  return resolverFindRoot(startPath);
+}
+
+function detectProjectName(repoPath: string): string {
+  try {
+    const remotes = execFileSync('git', ['-C', repoPath, 'remote', 'get-url', 'origin'],
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    const match = remotes.replace(/\.git$/, '').match(/[/:]([\w.-]+)$/);
+    if (match) return match[1];
+  } catch { /* no remote */ }
+  return path.basename(repoPath);
+}

package/src/core/ApiClient.ts

@@ -0,0 +1,197 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as zlib from 'zlib';
+import { promisify } from 'util';
+import type { StoredProvenance } from './FileProvenance';
+
+const _gzip = promisify(zlib.gzip);
+
+const CONFIG_PATH = path.join(os.homedir(), '.omnitype', 'config.json');
+const DEFAULT_API = 'https://api.imrishav.life';
+
+interface Config {
+  token?: string;
+  username?: string;
+  apiUrl?: string;
+}
+
+class Semaphore {
+  private queue: Array<() => void> = [];
+  private count: number;
+  constructor(max: number) { this.count = max; }
+  acquire(): Promise<void> {
+    if (this.count > 0) { this.count--; return Promise.resolve(); }
+    return new Promise(res => this.queue.push(res));
+  }
+  release(): void {
+    const next = this.queue.shift();
+    if (next) next(); else this.count++;
+  }
+}
+
+export class ApiClient {
+  private config: Config = {};
+
+  constructor() {
+    this._loadConfig();
+  }
+
+  private _loadConfig(): void {
+    try {
+      this.config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    } catch { this.config = {}; }
+  }
+
+  private _saveConfig(): void {
+    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(this.config, null, 2));
+  }
+
+  get apiUrl(): string {
+    return (this.config.apiUrl ?? DEFAULT_API).replace(/\/+$/, '');
+  }
+
+  get token(): string | undefined { return this.config.token; }
+  get username(): string | undefined { return this.config.username; }
+  get isSignedIn(): boolean { return !!this.config.token; }
+
+  async login(email: string, password: string): Promise<string> {
+    const res = await fetch(`${this.apiUrl}/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        identifier: email, password,
+        device_type: 'cli',
+        device_name: `omnitype-cli on ${os.hostname()}`,
+      }),
+    });
+    if (!res.ok) throw new Error(`Login failed: ${await res.text()}`);
+    const data = await res.json() as { token: string; user: { username: string } };
+    this.config.token    = data.token;
+    this.config.username = data.user.username;
+    this._saveConfig();
+    return data.user.username;
+  }
+
+  async pullProvenance(projectName: string, paths?: string[]): Promise<Record<string, any> | null> {
+    if (!this.config.token) return null;
+    try {
+      const body: any = { project_name: projectName };
+      if (paths?.length) body.paths = paths;
+      const res = await fetch(`${this.apiUrl}/provenance/pull`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.config.token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+      if (!res.ok) return null;
+      const data = await res.json() as { files?: Record<string, any> };
+      return data.files ?? null;
+    } catch { return null; }
+  }
+
+  async getPersonalStats(): Promise<any> {
+    if (!this.config.token) throw new Error('Not signed in. Run: omnitype login');
+    const res = await fetch(`${this.apiUrl}/provenance/personal/projects`, {
+      headers: { 'Authorization': `Bearer ${this.config.token}` },
+    });
+    if (!res.ok) throw new Error(`Failed to fetch stats: HTTP ${res.status}`);
+    return res.json();
+  }
+
+  async getProfile(): Promise<any> {
+    if (!this.config.token) throw new Error('Not signed in. Run: omnitype login');
+    const res = await fetch(`${this.apiUrl}/auth/me`, {
+      headers: { 'Authorization': `Bearer ${this.config.token}` },
+    });
+    if (!res.ok) throw new Error(`Failed to fetch profile: HTTP ${res.status}`);
+    return res.json();
+  }
+
+  logout(): void {
+    delete this.config.token;
+    delete this.config.username;
+    this._saveConfig();
+  }
+
+  async pushProvenance(
+    projectName: string,
+    branch: string,
+    files: Record<string, StoredProvenance>,
+    opts: { commitHash?: string; deletedFiles?: string[]; commitMessage?: string; personalOnly?: boolean; source?: string } = {},
+  ): Promise<void> {
+    if (!this.config.token) throw new Error('Not signed in. Run: omnitype login');
+
+    const fileEntries = Object.entries(files);
+    if (fileEntries.length === 0 && !opts.deletedFiles?.length) return;
+
+    const MAX_CHUNK = 400 * 1024;
+    const chunks    = this._buildChunks(fileEntries, MAX_CHUNK);
+    const total     = chunks.length || 1;
+    const effective = chunks.length > 0 ? chunks : [{}];
+    const sem       = new Semaphore(4);
+    const failed: number[] = [];
+
+    await Promise.all(effective.map(async (chunk, i) => {
+      await sem.acquire();
+      try {
+        const body: Record<string, unknown> = {
+          project_name: projectName, branch, files: chunk,
+          source: opts.source ?? 'cli-daemon',
+        };
+        if (i === 0) {
+          if (opts.commitHash)    body['commit_hash']    = opts.commitHash;
+          if (opts.commitMessage) body['commit_message'] = opts.commitMessage;
+          if (opts.deletedFiles?.length) body['deleted_files'] = opts.deletedFiles;
+          if (opts.personalOnly)  body['personal_only']  = true;
+        }
+        await this._postWithRetry(`${this.apiUrl}/provenance`, body, 3, `chunk ${i + 1}/${total}`);
+      } catch { failed.push(i + 1); }
+      finally { sem.release(); }
+    }));
+
+    if (failed.length) throw new Error(`Push failed for chunks: ${failed.join(', ')}`);
+  }
+
+  private async _postWithRetry(url: string, body: unknown, attempts: number, label: string): Promise<void> {
+    const compressed = await _gzip(Buffer.from(JSON.stringify(body)));
+    for (let i = 0; i < attempts; i++) {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.config.token}`,
+          'Content-Type': 'application/json',
+          'Content-Encoding': 'gzip',
+        },
+        body: compressed,
+      });
+      if (res.ok) return;
+      if (res.status < 500 || i === attempts - 1) throw new Error(`${label}: HTTP ${res.status}`);
+      await new Promise(r => setTimeout(r, 500 * 2 ** i));
+    }
+  }
+
+  private _buildChunks(
+    entries: Array<[string, StoredProvenance]>,
+    maxBytes: number,
+  ): Array<Record<string, StoredProvenance>> {
+    const chunks: Array<Record<string, StoredProvenance>> = [];
+    let cur: Record<string, StoredProvenance> = {};
+    let curBytes = 0;
+    for (const [k, v] of entries) {
+      const size = JSON.stringify(v).length;
+      if (curBytes + size > maxBytes && curBytes > 0) {
+        chunks.push(cur);
+        cur = {};
+        curBytes = 0;
+      }
+      cur[k] = v;
+      curBytes += size;
+    }
+    if (Object.keys(cur).length) chunks.push(cur);
+    return chunks;
+  }
+}