@omnitype-code/cli 0.1.0

package/src/daemon.ts

@@ -0,0 +1,171 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import { ApiClient } from './core/ApiClient';
+import { ModelDetector } from './core/ModelDetector';
+import { FileProvenance } from './core/FileProvenance';
+import type { StoredProvenance, LineHashBaseline } from './core/FileProvenance';
+import { extensionIsActiveFor, writeDaemonHeartbeat } from './core/Heartbeat';
+import { UI, COLORS } from './core/UI';
+
+const PUSH_INTERVAL_MS = 60_000;
+const IDLE_PUSH_MS     = 10_000;
+const IGNORE_DIRS      = /[/\\](\.git|node_modules|\.next|dist|build|__pycache__|\.venv|venv)[/\\]/;
+const TEXT_EXTS        = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h',
+  '.rb', '.php', '.cs', '.ex', '.exs', '.clj', '.scala', '.hs',
+  '.html', '.css', '.scss', '.less', '.vue', '.svelte',
+  '.json', '.yaml', '.yml', '.toml', '.md', '.mdx', '.txt',
+  '.sh', '.bash', '.zsh', '.fish', '.ps1',
+]);
+
+type LineBaseline = LineHashBaseline;
+
+function hashLine(s: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = (h * 0x01000193) >>> 0;
+  }
+  return h;
+}
+
+function toBaseline(content: string): LineBaseline[] {
+  return content.split('\n').map(l => ({ hash: hashLine(l), charLen: l.length + 1 }));
+}
+
+function gitBranch(repoPath: string): string {
+  try {
+    return execFileSync('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim();
+  } catch { return 'main'; }
+}
+
+function isTextFile(filePath: string): boolean {
+  return TEXT_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+export function startDaemon(opts: { watchPath: string; projectName: string; branch?: string }): void {
+  const api       = new ApiClient();
+  const detector  = new ModelDetector();
+  const baselines = new Map<string, LineBaseline[]>();
+  const dirtyFiles = new Set<string>();
+  const provenance = new Map<string, FileProvenance>();
+
+  if (!api.isSignedIn) {
+    UI.error('Not signed in. Run: omnitype login');
+    process.exit(1);
+  }
+
+  const watchPath   = path.resolve(opts.watchPath);
+  const projectName = opts.projectName;
+  const branch      = opts.branch ?? gitBranch(watchPath);
+
+  console.log(UI.box(
+    `${chalk.bold('Project:')} ${chalk.cyan(projectName)}\n` +
+    `${chalk.bold('Branch:')}  ${chalk.magenta(branch)}\n` +
+    `${chalk.bold('Path:')}    ${UI.dim(watchPath)}`,
+    `${UI.logo()} Sentinel Active`
+  ));
+
+  writeDaemonHeartbeat(watchPath);
+  setInterval(() => writeDaemonHeartbeat(watchPath), 10_000);
+
+  function seedFile(filePath: string): void {
+    if (!isTextFile(filePath) || IGNORE_DIRS.test(filePath)) return;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      baselines.set(filePath, toBaseline(content));
+      if (!provenance.has(filePath)) provenance.set(filePath, new FileProvenance(0));
+    } catch { /* unreadable */ }
+  }
+
+  function handleChange(filePath: string): void {
+    if (!isTextFile(filePath) || IGNORE_DIRS.test(filePath)) return;
+
+    let content: string;
+    try { content = fs.readFileSync(filePath, 'utf8'); }
+    catch { return; }
+
+    const newBaseline = toBaseline(content);
+    const oldBaseline = baselines.get(filePath) ?? [];
+    baselines.set(filePath, newBaseline);
+
+    if (oldBaseline.length === newBaseline.length &&
+        oldBaseline.every((b, i) => b.hash === newBaseline[i].hash)) return;
+
+    const detection = detector.detect(filePath);
+    const origin: 'ai' | 'user' = detection.tool !== 'unknown' ? 'ai' : 'user';
+
+    let prov = provenance.get(filePath);
+    if (!prov) { prov = new FileProvenance(0); provenance.set(filePath, prov); }
+
+    const modelId = origin === 'ai' ? prov.internModel(detection.model) : undefined;
+    prov.applyLineDiff(oldBaseline, newBaseline, origin, modelId);
+    dirtyFiles.add(filePath);
+
+    const rel = path.relative(watchPath, filePath);
+    const added = newBaseline.length - oldBaseline.length;
+    
+    const icon = origin === 'ai' ? chalk.hex(COLORS.ai)('✦') : chalk.hex(COLORS.user)('✎');
+    const modelTag = origin === 'ai' ? UI.dim(` (${detection.model})`) : '';
+    const diffTag = added !== 0 ? ` ${added > 0 ? '+' : ''}${added} lines` : '';
+    
+    console.log(`${icon} ${chalk.white(rel)}${diffTag}${modelTag}`);
+  }
+
+  let idleTimer: NodeJS.Timeout | null = null;
+
+  async function flush(): Promise<void> {
+    if (dirtyFiles.size === 0) return;
+
+    if (extensionIsActiveFor(watchPath)) {
+      UI.info('Yielding to VS Code extension (active)');
+      return;
+    }
+
+    const snapshot: Record<string, StoredProvenance> = {};
+    for (const f of dirtyFiles) {
+      const prov     = provenance.get(f);
+      const baseline = baselines.get(f);
+      if (prov && baseline) snapshot[path.relative(watchPath, f)] = prov.toStored(baseline);
+    }
+    dirtyFiles.clear();
+    try {
+      await api.pushProvenance(projectName, branch, snapshot, { source: 'cli-daemon' });
+      UI.success(`Synced ${Object.keys(snapshot).length} file(s) to cloud`);
+    } catch (err) {
+      UI.error(`Sync failed: ${err}`);
+      for (const rel of Object.keys(snapshot)) dirtyFiles.add(path.join(watchPath, rel));
+    }
+  }
+
+  function scheduleIdleFlush(): void {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => { idleTimer = null; flush(); }, IDLE_PUSH_MS);
+  }
+
+  const watcher = chokidar.watch(watchPath, {
+    ignoreInitial: false,
+    ignored: (p: string) => IGNORE_DIRS.test(p),
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+  });
+
+  watcher
+    .on('add',    (p: string) => seedFile(p))
+    .on('change', (p: string) => { handleChange(p); scheduleIdleFlush(); })
+    .on('unlink', (p: string) => { baselines.delete(p); provenance.delete(p); dirtyFiles.delete(p); })
+    .on('error',  (err: Error) => UI.error(`Watcher error: ${err.message}`));
+
+  setInterval(flush, PUSH_INTERVAL_MS);
+
+  const cleanup = () => { 
+    UI.info('Shutting down...');
+    flush().finally(() => process.exit(0)); 
+  };
+  process.on('SIGINT',  cleanup);
+  process.on('SIGTERM', cleanup);
+}

package/src/hooks.ts

@@ -0,0 +1,195 @@
+/**
+ * Git hook installer for omnitype.
+ *
+ * Installs a post-commit hook that calls `omnitype commit-scan` after each commit.
+ * Non-destructive: appends to existing hooks rather than replacing them.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { execFileSync } from 'child_process';
+import { ApiClient } from './core/ApiClient';
+import { ModelDetector } from './core/ModelDetector';
+import { FileProvenance } from './core/FileProvenance';
+import type { StoredProvenance, LineHashBaseline } from './core/FileProvenance';
+import { writeNote, buildNote, provenanceToNoteFile } from './core/GitNotes';
+
+const MARKER     = '# omnitype provenance — do not edit this block';
+const MARKER_END = '# /omnitype';
+
+function findGitDir(cwd: string): string | undefined {
+  let dir = cwd;
+  for (let i = 0; i < 20; i++) {
+    const candidate = path.join(dir, '.git');
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+  return undefined;
+}
+
+export function installHooks(cwd = process.cwd()): void {
+  const gitDir = findGitDir(cwd);
+  if (!gitDir) throw new Error('Not inside a git repository.');
+
+  const hooksDir = path.join(gitDir, 'hooks');
+  fs.mkdirSync(hooksDir, { recursive: true });
+  const hookFile = path.join(hooksDir, 'post-commit');
+
+  // Build hook snippet
+  const omnityeBin = process.execPath === process.argv[0]
+    ? 'omnitype'
+    : `node "${process.argv[1]}"`;
+
+  const snippet = [
+    MARKER,
+    `${omnityeBin} commit-scan --repo "$(git rev-parse --show-toplevel)"`,
+    MARKER_END,
+    '',
+  ].join('\n');
+
+  let existing = '';
+  try { existing = fs.readFileSync(hookFile, 'utf8'); } catch { /* new file */ }
+
+  if (existing.includes(MARKER)) {
+    console.log('omnitype: git hook already installed.');
+    return;
+  }
+
+  const content = existing
+    ? `${existing.trimEnd()}\n\n${snippet}`
+    : `#!/bin/sh\n${snippet}`;
+
+  fs.writeFileSync(hookFile, content);
+  if (os.platform() !== 'win32') fs.chmodSync(hookFile, 0o755);
+  console.log('omnitype: post-commit hook installed.');
+}
+
+export function uninstallHooks(cwd = process.cwd()): void {
+  const gitDir = findGitDir(cwd);
+  if (!gitDir) throw new Error('Not inside a git repository.');
+
+  const hookFile = path.join(gitDir, 'hooks', 'post-commit');
+  let content: string;
+  try { content = fs.readFileSync(hookFile, 'utf8'); }
+  catch { console.log('omnitype: no hook file found.'); return; }
+
+  if (!content.includes(MARKER)) {
+    console.log('omnitype: omnitype hook not found in post-commit.');
+    return;
+  }
+
+  const start = content.indexOf(MARKER);
+  const end   = content.indexOf(MARKER_END);
+  let updated = content.slice(0, start) + content.slice(end + MARKER_END.length);
+  updated = updated.replace(/\n{3,}/g, '\n\n').trim();
+
+  if (!updated || updated === '#!/bin/sh') {
+    fs.rmSync(hookFile);
+  } else {
+    fs.writeFileSync(hookFile, updated + '\n');
+  }
+  console.log('omnitype: post-commit hook removed.');
+}
+
+/**
+ * Called by the post-commit hook. Diffs HEAD against HEAD~1, attributing
+ * added lines as AI if a tool is currently active, otherwise as 'user'.
+ */
+export async function commitScan(repoPath: string): Promise<void> {
+  const api = new ApiClient();
+
+  // Get the commit hash and message
+  const commitHash = run('git', ['-C', repoPath, 'rev-parse', 'HEAD']).trim();
+  const commitMsg  = run('git', ['-C', repoPath, 'log', '-1', '--format=%s']).trim();
+  const branch     = run('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD']).trim();
+  const projectName = path.basename(repoPath);
+
+  // Detect the active model
+  const detector = new ModelDetector();
+  const detection = detector.detect();
+
+  // Get diff of committed files (HEAD vs HEAD~1, or HEAD vs empty if first commit)
+  let diffOutput: string;
+  try {
+    diffOutput = run('git', ['-C', repoPath, 'diff', '--unified=0', 'HEAD~1', 'HEAD']);
+  } catch {
+    // First commit — diff against empty tree
+    diffOutput = run('git', ['-C', repoPath, 'diff', '--unified=0', '4b825dc642cb6eb9a060e54bf8d69288fbee4904', 'HEAD']);
+  }
+
+  const files = parseDiffToProvenance(diffOutput, detection.tool !== 'unknown' ? 'ai' : 'user', detection.model);
+
+  if (Object.keys(files).length === 0) {
+    process.stdout.write('omnitype: nothing to record for this commit.\n');
+    return;
+  }
+
+  // Write Git Note first (local, always works even offline)
+  try {
+    const noteFile = provenanceToNoteFile(files);
+    const note     = buildNote(noteFile);
+    await writeNote(repoPath, commitHash, note);
+    process.stdout.write(`omnitype: git note written for ${commitHash.slice(0, 7)}\n`);
+  } catch (err) {
+    process.stderr.write(`omnitype: git note failed — ${err}\n`);
+  }
+
+  // Push to cloud (best-effort)
+  if (api.isSignedIn) {
+    try {
+      await api.pushProvenance(projectName, branch, files, { commitHash, commitMessage: commitMsg, source: 'cli-hook' });
+      process.stdout.write(`omnitype: pushed ${Object.keys(files).length} file(s) to cloud\n`);
+    } catch (err) {
+      process.stderr.write(`omnitype: cloud push failed — ${err}\n`);
+    }
+  }
+}
+
+function run(cmd: string, args: string[]): string {
+  return execFileSync(cmd, args, { encoding: 'utf8' });
+}
+
+type Origin = 'ai' | 'user' | 'paste' | 'existing';
+
+function hashLine(s: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = (h * 0x01000193) >>> 0; }
+  return h;
+}
+
+function parseDiffToProvenance(
+  diff: string,
+  origin: Origin,
+  model: string,
+): Record<string, StoredProvenance> {
+  // Collect added lines per file, then build provenance from scratch
+  const fileLines: Record<string, string[]> = {};
+  let currentFile: string | null = null;
+
+  for (const line of diff.split('\n')) {
+    if (line.startsWith('+++ b/')) {
+      currentFile = line.slice(6).trim();
+      if (!fileLines[currentFile]) fileLines[currentFile] = [];
+      continue;
+    }
+    if (!currentFile) continue;
+    if (line.startsWith('+') && !line.startsWith('+++')) {
+      fileLines[currentFile].push(line.slice(1));
+    }
+  }
+
+  const result: Record<string, StoredProvenance> = {};
+  for (const [relPath, lines] of Object.entries(fileLines)) {
+    if (lines.length === 0) continue;
+    const prov = new FileProvenance(0);
+    const modelId = origin === 'ai' ? prov.internModel(model) : undefined;
+    const baseline: LineHashBaseline[] = lines.map(l => ({ hash: hashLine(l), charLen: l.length + 1 }));
+    // Build the baseline first, then apply a diff from empty → lines
+    prov.applyLineDiff([], baseline, origin, modelId);
+    result[relPath] = prov.toStored(baseline);
+  }
+  return result;
+}