@omnitype-code/cli 0.1.0

package/src/core/ProvenanceResolver.ts

@@ -0,0 +1,433 @@
+/**
+ * ProvenanceResolver — merges git notes + .omni (StoredProvenance) into a
+ * single authoritative hash→LineInfo map for a file.
+ *
+ * Precedence (higher wins):
+ *   ai(3) > paste(2) > user(1) > existing(0)
+ *
+ * Rule:
+ *   - git notes are authoritative for committed history
+ *   - .omni fills gaps where notes say 'existing'
+ *   - own tracked (non-existing) origins are NEVER overwritten
+ *   - trivial lines (charLen ≤ MIN_HINT_CHARLEN) are skipped to guard
+ *     against FNV hash collisions
+ */
+
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { readNote } from './GitNotes';
+import type { NoteRange } from './GitNotes';
+
+export type Origin = 'ai' | 'user' | 'paste' | 'existing';
+
+export interface LineInfo {
+  origin: Origin;
+  model?: string;
+  tool?:  string;
+}
+
+/** hash → LineInfo */
+export type HintMap = Map<number, LineInfo>;
+
+// Origin precedence: ai=3, paste=2, user=1, existing=0
+const ORIGIN_PREC: Record<Origin, number> = { existing: 0, user: 1, paste: 2, ai: 3 };
+
+const ORIGIN_DECODE: Origin[] = ['existing', 'user', 'ai', 'paste'];
+
+const MIN_HINT_CHARLEN = 8;
+
+// ── FNV-1a 32-bit (matches extension's TypingTracker.hashLine) ───────────────
+export function fnv1a(s: string): number {
+  const canonical = s.trim();
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < canonical.length; i++) {
+    h = (h ^ canonical.charCodeAt(i)) >>> 0;
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+
+// ── StoredProvenance (mirrors extension's interface) ─────────────────────────
+export interface StoredProvenance {
+  hashes:          number[];
+  origins:         number[];
+  charLens:        number[];
+  modelDictionary?: string[];
+  modelIds?:       number[];
+  toolDictionary?: string[];
+  toolIds?:        number[];
+}
+
+type OmniDisk = Record<string, Record<string, StoredProvenance>>;
+
+// ── Merge helpers ─────────────────────────────────────────────────────────────
+
+/** Merge two HintMaps — higher precedence origin wins per hash. */
+export function mergeHints(...maps: HintMap[]): HintMap {
+  const out: HintMap = new Map();
+  for (const map of maps) {
+    for (const [hash, info] of map) {
+      const prev = out.get(hash);
+      if (!prev || ORIGIN_PREC[info.origin] > ORIGIN_PREC[prev.origin]) {
+        out.set(hash, info);
+      }
+    }
+  }
+  return out;
+}
+
+// ── Source: git notes ─────────────────────────────────────────────────────────
+
+/**
+ * Build a HintMap by scanning git notes on the last N commits for a file.
+ * Returns hash→LineInfo by hashing each line's content from the working tree.
+ */
+export function hintsFromGitNotes(
+  repoPath: string,
+  relPath:  string,
+  absPath:  string,
+  maxCommits = 50,
+): HintMap {
+  const map: HintMap = new Map();
+
+  // Read current file to build hash→lineContent lookup
+  let fileLines: string[];
+  try {
+    fileLines = fs.readFileSync(absPath, 'utf8').split('\n');
+  } catch { return map; }
+
+  // Scan recent commits for a note that covers this file
+  let ranges: NoteRange[] | undefined;
+  try {
+    const log = execFileSync(
+      'git', ['-C', repoPath, 'log', '--format=%H', `-${maxCommits}`],
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim().split('\n').filter(Boolean);
+
+    for (const sha of log) {
+      const note = readNote(repoPath, sha);
+      // Extension writes git note keys with a leading '/' (same as .omni keys)
+      const fileData = note?.files[relPath] ?? note?.files['/' + relPath];
+      if (fileData) { ranges = fileData; break; }
+    }
+  } catch { return map; }
+
+  if (!ranges) return map;
+
+  // Expand ranges → line number → LineInfo, then hash the actual line content
+  for (const r of ranges) {
+    if (r.origin === 'existing') continue;
+    for (let ln = r.start; ln <= r.end; ln++) {
+      const content = fileLines[ln - 1]; // 1-indexed
+      if (content === undefined) continue;
+      if (content.trim().length < MIN_HINT_CHARLEN) continue;
+      const hash = fnv1a(content);
+      const prev = map.get(hash);
+      if (!prev || ORIGIN_PREC[r.origin] > ORIGIN_PREC[prev.origin]) {
+        map.set(hash, { origin: r.origin, model: r.model, tool: r.tool });
+      }
+    }
+  }
+
+  return map;
+}
+
+// ── Source: .omni file ────────────────────────────────────────────────────────
+
+/** Read .omni in repoPath and return a HintMap for the given branch + relPath. */
+/**
+ * Load .omni and reconcile stored line hashes against current file content
+ * using LCS — same algorithm as FileProvenance.fromStored() in the extension.
+ *
+ * Returns a 1-indexed lineNumber → LineInfo map for the current file.
+ * Lines that don't match any stored line get no entry (treated as existing).
+ */
+export function lineMapFromOmni(
+  repoPath: string,
+  branch:   string,
+  relPath:  string,
+  currentLines: string[],
+): Map<number, LineInfo> {
+  const result = new Map<number, LineInfo>();
+  const omniPath = path.join(repoPath, '.omni');
+  if (!fs.existsSync(omniPath)) return result;
+
+  try {
+    const disk: OmniDisk = JSON.parse(fs.readFileSync(omniPath, 'utf8'));
+    const branchData = disk[branch] ?? disk[Object.keys(disk)[0]];
+    if (!branchData) return result;
+    // .omni keys use URI-relative paths with a leading '/' (extension writes '/src/foo.ts').
+    // Prefer the '/'-prefixed key — it is always the canonical extension-written entry.
+    // Fall back to the unprefixed form for CLI-written entries.
+    const stored = branchData['/' + relPath] ?? branchData[relPath];
+    if (!stored) return result;
+
+    const storedHashes  = stored.hashes;
+    const currentHashes = currentLines.map(l => fnv1a(l));
+    const m = storedHashes.length;
+    const n = currentHashes.length;
+
+    // LCS table (same as FileProvenance.fromStored)
+    const MAX_LCS = 3000; // match extension's FileProvenance.MAX_LCS_SIDE
+    if (m > MAX_LCS || n > MAX_LCS) {
+      // Fall back to direct hash lookup for very large files
+      const hashToInfo = new Map<number, LineInfo>();
+      for (let i = 0; i < m; i++) {
+        const origin = ORIGIN_DECODE[stored.origins[i] ?? 0] ?? 'existing';
+        if (origin === 'existing') continue;
+        const modelId = stored.modelIds?.[i] ?? -1;
+        const model   = modelId >= 0 ? stored.modelDictionary?.[modelId] : undefined;
+        const toolId  = stored.toolIds?.[i]  ?? -1;
+        const tool    = toolId  >= 0 ? stored.toolDictionary?.[toolId]  : undefined;
+        hashToInfo.set(storedHashes[i], { origin, model, tool });
+      }
+      currentLines.forEach((line, idx) => {
+        const info = hashToInfo.get(currentHashes[idx]);
+        if (info && info.origin !== 'existing') result.set(idx + 1, info);
+      });
+      return result;
+    }
+
+    const t: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        t[i][j] = storedHashes[i - 1] === currentHashes[j - 1]
+          ? t[i - 1][j - 1] + 1
+          : Math.max(t[i - 1][j], t[i][j - 1]);
+      }
+    }
+
+    // Backtrack — assign stored origins to matched current lines
+    let i = m, j = n;
+    while (i > 0 && j > 0) {
+      if (storedHashes[i - 1] === currentHashes[j - 1] && t[i][j] === t[i - 1][j - 1] + 1) {
+        const origin = ORIGIN_DECODE[stored.origins[i - 1] ?? 0] ?? 'existing';
+        if (origin !== 'existing') {
+          const modelId = stored.modelIds?.[i - 1] ?? -1;
+          const model   = modelId >= 0 ? stored.modelDictionary?.[modelId] : undefined;
+          const toolId  = stored.toolIds?.[i - 1]  ?? -1;
+          const tool    = toolId  >= 0 ? stored.toolDictionary?.[toolId]  : undefined;
+          result.set(j, { origin, model, tool }); // j is 1-indexed current line
+        }
+        i--; j--;
+      } else if (t[i - 1][j] >= t[i][j - 1]) {
+        i--;
+      } else {
+        j--;
+      }
+    }
+  } catch { /* corrupt .omni */ }
+
+  return result;
+}
+
+// ── Apply hints to StoredProvenance ──────────────────────────────────────────
+
+/**
+ * Upgrade 'existing' lines in a StoredProvenance using a HintMap.
+ * Only lines with origin=existing (0) are touched — own tracked origins stay.
+ * Returns true if any lines were upgraded.
+ */
+export function applyHints(stored: StoredProvenance, hints: HintMap): boolean {
+  if (hints.size === 0) return false;
+  let changed = false;
+
+  for (let i = 0; i < stored.hashes.length; i++) {
+    if (stored.origins[i] !== 0) continue; // never overwrite tracked origin
+    if ((stored.charLens[i] ?? 0) < MIN_HINT_CHARLEN) continue;
+
+    const hint = hints.get(stored.hashes[i]);
+    if (!hint || hint.origin === 'existing') continue;
+
+    const originCode = ORIGIN_DECODE.indexOf(hint.origin);
+    if (originCode < 0) continue;
+
+    stored.origins[i] = originCode;
+    changed = true;
+
+    // Inject model
+    if (hint.model) {
+      stored.modelDictionary ??= [];
+      stored.modelIds ??= new Array(stored.hashes.length).fill(-1);
+      let mIdx = stored.modelDictionary.indexOf(hint.model);
+      if (mIdx === -1) { mIdx = stored.modelDictionary.length; stored.modelDictionary.push(hint.model); }
+      stored.modelIds[i] = mIdx;
+    }
+
+    // Inject tool
+    if (hint.tool) {
+      stored.toolDictionary ??= [];
+      stored.toolIds ??= new Array(stored.hashes.length).fill(-1);
+      let tIdx = stored.toolDictionary.indexOf(hint.tool);
+      if (tIdx === -1) { tIdx = stored.toolDictionary.length; stored.toolDictionary.push(hint.tool); }
+      stored.toolIds[i] = tIdx;
+    }
+  }
+
+  return changed;
+}
+
+// ── High-level: resolve a file's full line map ────────────────────────────────
+
+/**
+ * Build a lineNumber→LineInfo map from a StoredProvenance fetched from the API.
+ * Uses LCS reconciliation against current file lines — same as lineMapFromOmni.
+ */
+export function lineMapFromApiStored(
+  stored:       StoredProvenance,
+  currentLines: string[],
+): Map<number, LineInfo> {
+  return lineMapFromStoredInner(stored, currentLines);
+}
+
+function lineMapFromStoredInner(
+  stored:       StoredProvenance,
+  currentLines: string[],
+): Map<number, LineInfo> {
+  const result = new Map<number, LineInfo>();
+  const storedHashes  = stored.hashes;
+  const currentHashes = currentLines.map(l => fnv1a(l));
+  const m = storedHashes.length;
+  const n = currentHashes.length;
+
+  const MAX_LCS = 3000; // match extension's FileProvenance.MAX_LCS_SIDE
+  if (m > MAX_LCS || n > MAX_LCS) {
+    const hashToInfo = new Map<number, LineInfo>();
+    for (let i = 0; i < m; i++) {
+      const origin = ORIGIN_DECODE[stored.origins[i] ?? 0] ?? 'existing';
+      if (origin === 'existing') continue;
+      const modelId = stored.modelIds?.[i] ?? -1;
+      const model   = modelId >= 0 ? stored.modelDictionary?.[modelId] : undefined;
+      const toolId  = stored.toolIds?.[i]  ?? -1;
+      const tool    = toolId  >= 0 ? stored.toolDictionary?.[toolId]  : undefined;
+      hashToInfo.set(storedHashes[i], { origin, model, tool });
+    }
+    currentLines.forEach((line, idx) => {
+      const info = hashToInfo.get(currentHashes[idx]);
+      if (info && info.origin !== 'existing') result.set(idx + 1, info);
+    });
+    return result;
+  }
+
+  const t: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      t[i][j] = storedHashes[i - 1] === currentHashes[j - 1]
+        ? t[i - 1][j - 1] + 1
+        : Math.max(t[i - 1][j], t[i][j - 1]);
+
+  let i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (storedHashes[i - 1] === currentHashes[j - 1] && t[i][j] === t[i - 1][j - 1] + 1) {
+      const origin = ORIGIN_DECODE[stored.origins[i - 1] ?? 0] ?? 'existing';
+      if (origin !== 'existing') {
+        const modelId = stored.modelIds?.[i - 1] ?? -1;
+        const model   = modelId >= 0 ? stored.modelDictionary?.[modelId] : undefined;
+        const toolId  = stored.toolIds?.[i - 1]  ?? -1;
+        const tool    = toolId  >= 0 ? stored.toolDictionary?.[toolId]  : undefined;
+        result.set(j, { origin, model, tool });
+      }
+      i--; j--;
+    } else if (t[i - 1][j] >= t[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return result;
+}
+
+/**
+ * Resolve the authoritative LineInfo for every line of a file.
+ * Priority: API (live cloud data) > git notes > .omni
+ *
+ * Used by `omnitype blame` and any CLI command that needs per-line attribution.
+ */
+export async function resolveFileLinesAsync(
+  repoPath:    string,
+  relPath:     string,
+  absPath:     string,
+  branch:      string,
+  projectName: string,
+): Promise<Map<number, LineInfo>> {
+  let currentLines: string[];
+  try {
+    currentLines = fs.readFileSync(absPath, 'utf8').split('\n');
+  } catch { return new Map(); }
+
+  // Start with local sources (.omni + git notes) — most complete for current device
+  const localMap = resolveFileLines(repoPath, relPath, absPath, branch);
+
+  // Merge with API — fills lines local doesn't have (pushed from other devices)
+  // Local wins when it already has attribution; API only adds what's missing
+  try {
+    const { ApiClient } = await import('./ApiClient');
+    const api = new ApiClient();
+    if (api.isSignedIn) {
+      const files = await api.pullProvenance(projectName, [relPath, '/' + relPath]);
+      const apiStored = files?.[relPath] ?? files?.['/' + relPath];
+      if (apiStored?.hashes?.length) {
+        const apiMap = lineMapFromStoredInner(apiStored as StoredProvenance, currentLines);
+        for (const [lineNum, apiInfo] of apiMap) {
+          if (!localMap.has(lineNum)) {
+            // API has data local doesn't — add it
+            localMap.set(lineNum, apiInfo);
+          }
+        }
+      }
+    }
+  } catch { /* use local only */ }
+
+  return localMap;
+}
+
+/**
+ * Synchronous fallback — .omni + git notes only.
+ */
+export function resolveFileLines(
+  repoPath: string,
+  relPath:  string,
+  absPath:  string,
+  branch:   string,
+): Map<number, LineInfo> {
+  let currentLines: string[];
+  try {
+    currentLines = fs.readFileSync(absPath, 'utf8').split('\n');
+  } catch { return new Map(); }
+
+  const omniLineMap = lineMapFromOmni(repoPath, branch, relPath, currentLines);
+  const gitHints    = hintsFromGitNotes(repoPath, relPath, absPath);
+
+  const lineMap = new Map<number, LineInfo>(omniLineMap);
+  for (const [lineNum, info] of lineMap) {
+    const gitInfo = gitHints.get(fnv1a(currentLines[lineNum - 1] ?? ''));
+    if (gitInfo && ORIGIN_PREC[gitInfo.origin] > ORIGIN_PREC[info.origin]) {
+      lineMap.set(lineNum, gitInfo);
+    }
+  }
+  currentLines.forEach((content, idx) => {
+    const lineNum = idx + 1;
+    if (lineMap.has(lineNum)) return;
+    const gitInfo = gitHints.get(fnv1a(content));
+    if (gitInfo && gitInfo.origin !== 'existing') lineMap.set(lineNum, gitInfo);
+  });
+
+  return lineMap;
+}
+
+export function getCurrentBranch(repoPath: string): string {
+  try {
+    return execFileSync('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'],
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch { return 'main'; }
+}
+
+export function findRepoRoot(startPath: string): string | undefined {
+  try {
+    return execFileSync(
+      'git', ['-C', path.dirname(startPath), 'rev-parse', '--show-toplevel'],
+      { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+  } catch { return undefined; }
+}

package/src/core/UI.ts

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora from 'ora';
+import gradient from 'gradient-string';
+
+export const COLORS = {
+  primary:   '#00D1FF',
+  secondary: '#7000FF',
+  success:   '#00FF94',
+  warning:   '#FFB800',
+  error:     '#FF4D4D',
+  ai:        '#BD00FF',
+  user:      '#00D1FF',
+  paste:     '#FFB800',
+};
+
+// Pixelated logo derived from the SVG: circle + dashed arc + center dot
+const LOGO_PIXELS = [
+  '   ▄▄▄▄▄▄▄▄▄▄▄   ',
+  ' ▄█           █▄ ',
+  '██  ╌ ╌ ● ╌ ╌  ██',
+  ' ▀█           █▀ ',
+  '   ▀▀▀▀▀▀▀▀▀▀▀   ',
+];
+
+export class UI {
+  static pixelLogo(): string {
+    return LOGO_PIXELS
+      .map(line => gradient([COLORS.primary, COLORS.secondary, COLORS.ai])(line))
+      .join('\n');
+  }
+
+  static banner(): string {
+    const g = (s: string) => chalk.bold(gradient([COLORS.primary, COLORS.secondary, COLORS.ai])(s));
+    return [
+      '',
+      g(' ██████╗ ███╗   ███╗███╗   ██╗██╗'),
+      g('██╔═══██╗████╗ ████║████╗  ██║██║'),
+      g('██║   ██║██╔████╔██║██╔██╗ ██║██║'),
+      g('██║   ██║██║╚██╔╝██║██║╚██╗██║██║'),
+      g('╚██████╔╝██║ ╚═╝ ██║██║ ╚████║██║'),
+      g(' ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═══╝╚═╝'),
+      chalk.hex(COLORS.primary).dim(' code provenance · any editor · any model'),
+      '',
+    ].join('\n');
+  }
+
+  static logo(): string {
+    return chalk.bold(gradient(COLORS.primary, COLORS.secondary)('OmniType'));
+  }
+
+  static box(content: string, title?: string) {
+    return boxen(content, {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: COLORS.primary,
+      title: title ? chalk.bold(gradient(COLORS.primary, COLORS.secondary)(title)) : undefined,
+      titleAlignment: 'center',
+    });
+  }
+
+  static spinner(text: string) {
+    return ora({
+      text,
+      color: 'cyan',
+      spinner: 'dots12',
+    }).start();
+  }
+
+  static error(message: string) {
+    console.error(chalk.hex(COLORS.error)('✖ ') + message);
+  }
+
+  static success(message: string) {
+    console.log(chalk.hex(COLORS.success)('✔ ') + message);
+  }
+
+  static info(message: string) {
+    console.log(chalk.hex(COLORS.primary)('ℹ ') + message);
+  }
+
+  static dim(message: string) {
+    return chalk.gray(message);
+  }
+
+  static bold(message: string) {
+    return chalk.bold(message);
+  }
+
+  static label(text: string, color: string = COLORS.primary) {
+    return chalk.bgHex(color).black(` ${text} `);
+  }
+
+  static bar(value: number, total: number, width = 20, color = COLORS.primary): string {
+    const filled = total === 0 ? 0 : Math.round((value / total) * width);
+    return chalk.hex(color)('█'.repeat(filled)) + chalk.gray('░'.repeat(width - filled));
+  }
+
+  static pct(value: number, total: number): string {
+    const p = total === 0 ? 0 : (value / total) * 100;
+    const color = p > 60 ? COLORS.ai : p > 30 ? COLORS.warning : COLORS.success;
+    return chalk.hex(color)(`${p.toFixed(1)}%`);
+  }
+}