@omnitype-code/cli 0.1.0

package/dist/core/ModelDetector.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * CLI ModelDetector — editor-agnostic model detection.
+ *
+ * Detection tiers:
+ *   1. Universal sentinel   (~/.omnitype/active-model.json)
+ *   2. Hooks sentinel file  (~/.claude/provenance-hook.json)
+ *   3. Host IDE config      (Cursor/Windsurf/Zed settings.json — scanned generically)
+ *   4. Config files         (per-tool config paths: .aider.conf.yml, etc.)
+ *   5. Environment variables (CLAUDE_MODEL, AIDER_MODEL, etc.)
+ *   6. Process detection    (lsof / ps — identifies the writing process)
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelDetector = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const UNKNOWN = { model: 'unknown', tool: 'unknown', confidence: 'low' };
+const HOOKS_SENTINEL_PATH = path.join(os.homedir(), '.claude', 'provenance-hook.json');
+const UNIVERSAL_SENTINEL_PATH = path.join(os.homedir(), '.omnitype', 'active-model.json');
+const SENTINEL_MAX_AGE_MS = 10000;
+const MODEL_PATTERN = /\b(claude-[\w.-]+|gpt-[\w.-]+|o[1234](?:-[\w.-]+)?|gemini-[\w.-]+|gemma[\w.-]*|llama-[\w.-]+|mistral[\w.-]*|codestral[\w.-]*|deepseek[\w.-]*|qwen[\w.-]+|command[\w.-]*|phi[\w.-]+|grok[\w.-]*|kimi[\w.-]*|moonshot[\w.-]*)\b/i;
+// Maps known CLI/IDE env vars to their tool
+const ENV_VARS = [
+    { vars: ['CLAUDE_MODEL', 'CLAUDE_CODE_MODEL', 'ANTHROPIC_MODEL'], tool: 'claude-code' },
+    { vars: ['AIDER_MODEL'], tool: 'aider' },
+    { vars: ['OPENAI_MODEL', 'OPENAI_API_MODEL'], tool: 'openai' },
+    { vars: ['GEMINI_MODEL', 'GEMINI_API_KEY'], tool: 'gemini-cli' },
+    { vars: ['OLLAMA_MODEL'], tool: 'ollama' },
+    { vars: ['COPILOT_MODEL'], tool: 'copilot' },
+    { vars: ['LLM_MODEL'], tool: 'openhands' },
+    { vars: ['TABBY_MODEL'], tool: 'tabby' },
+];
+const KNOWN_FORKS = [
+    'Cursor', 'Windsurf', 'PearAI', 'Void', 'Trae', 'Zed', 'Antigravity'
+];
+// lsof command-name → tool mapping
+const LSOF_CMD_MAP = [
+    { match: 'claude', tool: 'claude-code' },
+    { match: 'aider', tool: 'aider' },
+    { match: 'cursor', tool: 'cursor' },
+    { match: 'windsurf', tool: 'windsurf' },
+    { match: 'zed', tool: 'zed' },
+    { match: 'pearai', tool: 'pearai' },
+    { match: 'void', tool: 'void' },
+    { match: 'tabby', tool: 'tabby' },
+    { match: 'goose', tool: 'goose' },
+    { match: 'node', tool: 'unknown-cli' },
+    { match: 'python', tool: 'unknown-cli' },
+];
+class ModelDetector {
+    detect(changedFilePath) {
+        return (this._fromUniversalSentinel() ??
+            this._fromHooksSentinel() ??
+            this._fromIdeConfigs() ??
+            this._fromEnv() ??
+            this._fromPsPatterns() ??
+            (changedFilePath ? this._fromLsof(changedFilePath) : undefined) ??
+            UNKNOWN);
+    }
+    _fromUniversalSentinel() {
+        try {
+            const stat = fs.statSync(UNIVERSAL_SENTINEL_PATH);
+            if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS)
+                return undefined;
+            const data = JSON.parse(fs.readFileSync(UNIVERSAL_SENTINEL_PATH, 'utf8'));
+            if (!data?.model || data.model === 'unknown')
+                return undefined;
+            return { model: data.model, tool: data.tool ?? 'unknown-tool', confidence: 'deterministic' };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    _fromHooksSentinel() {
+        try {
+            const stat = fs.statSync(HOOKS_SENTINEL_PATH);
+            if (Date.now() - stat.mtimeMs > SENTINEL_MAX_AGE_MS)
+                return undefined;
+            const data = JSON.parse(fs.readFileSync(HOOKS_SENTINEL_PATH, 'utf8'));
+            if (!data?.model || data.model === 'unknown')
+                return undefined;
+            return { model: data.model, tool: data.tool ?? 'claude-code', confidence: 'deterministic' };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    _fromIdeConfigs() {
+        for (const appName of KNOWN_FORKS) {
+            const scan = this._scanIdeSettings(appName);
+            if (scan) {
+                return {
+                    model: scan.model,
+                    tool: appName.toLowerCase(),
+                    confidence: scan.isAuto ? 'medium' : 'high'
+                };
+            }
+        }
+        return undefined;
+    }
+    _fromEnv() {
+        for (const { vars, tool } of ENV_VARS) {
+            for (const v of vars) {
+                const val = process.env[v];
+                if (val && MODEL_PATTERN.test(val)) {
+                    return { model: val, tool, confidence: 'high' };
+                }
+            }
+        }
+        return undefined;
+    }
+    _fromPsPatterns() {
+        if (process.platform === 'win32')
+            return undefined;
+        try {
+            const lines = (0, child_process_1.execFileSync)('ps', ['ax', '-o', 'args='], { timeout: 800, encoding: 'utf8' }).split('\n');
+            for (const line of lines) {
+                for (const entry of LSOF_CMD_MAP) {
+                    if (line.toLowerCase().includes(entry.match)) {
+                        // Fallback model name
+                        return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
+                    }
+                }
+            }
+        }
+        catch { /* ps unavailable */ }
+        return undefined;
+    }
+    _fromLsof(filePath) {
+        if (process.platform === 'win32')
+            return undefined;
+        try {
+            const out = (0, child_process_1.execFileSync)('lsof', ['-F', 'c', filePath], { timeout: 800, encoding: 'utf8' });
+            for (const line of out.split('\n')) {
+                if (!line.startsWith('c'))
+                    continue;
+                const cmd = line.slice(1).toLowerCase();
+                for (const entry of LSOF_CMD_MAP) {
+                    if (cmd.includes(entry.match)) {
+                        return { model: `${entry.tool}-default`, tool: entry.tool, confidence: 'low' };
+                    }
+                }
+            }
+        }
+        catch { /* lsof unavailable */ }
+        return undefined;
+    }
+    _scanIdeSettings(appName) {
+        for (const p of this._getIdeSettingsPaths(appName)) {
+            try {
+                const raw = fs.readFileSync(p, 'utf8');
+                const json = JSON.parse(raw);
+                const flat = this._flattenObject(json);
+                const AUTO_SENTINELS = new Set(['auto', 'cursor-auto', 'windsurf-auto', 'default', 'best']);
+                const candidates = [];
+                for (const [key, value] of Object.entries(flat)) {
+                    if (typeof value !== 'string' || !value)
+                        continue;
+                    if (!key.toLowerCase().includes('model'))
+                        continue;
+                    if (AUTO_SENTINELS.has(value.toLowerCase())) {
+                        candidates.push({ key, value: `${appName.toLowerCase()}-auto` });
+                        continue;
+                    }
+                    if (MODEL_PATTERN.test(value)) {
+                        candidates.push({ key, value: value.toLowerCase() });
+                    }
+                }
+                if (candidates.length > 0) {
+                    const real = candidates.filter(c => !c.value.endsWith('-auto'));
+                    const pick = real.length > 0
+                        ? real.sort((a, b) => b.key.length - a.key.length)[0]
+                        : candidates.sort((a, b) => b.key.length - a.key.length)[0];
+                    return { model: pick.value, isAuto: pick.value.endsWith('-auto') };
+                }
+            }
+            catch { /* absent */ }
+        }
+        return undefined;
+    }
+    _getIdeSettingsPaths(appName) {
+        const toolId = appName.toLowerCase().replace(/\s+/g, '-');
+        const dirCandidates = [...new Set([appName, toolId])];
+        return dirCandidates.map(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');
+            }
+        });
+    }
+    _flattenObject(obj, prefix = '', depth = 0) {
+        if (depth > 5)
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            const key = prefix ? `${prefix}.${k}` : k;
+            if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+                Object.assign(out, this._flattenObject(v, key, depth + 1));
+            }
+            else {
+                out[key] = v;
+            }
+        }
+        return out;
+    }
+}
+exports.ModelDetector = ModelDetector;

package/dist/core/ProvenanceResolver.js

@@ -0,0 +1,424 @@
+"use strict";
+/**
+ * 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
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv1a = fnv1a;
+exports.mergeHints = mergeHints;
+exports.hintsFromGitNotes = hintsFromGitNotes;
+exports.lineMapFromOmni = lineMapFromOmni;
+exports.applyHints = applyHints;
+exports.lineMapFromApiStored = lineMapFromApiStored;
+exports.resolveFileLinesAsync = resolveFileLinesAsync;
+exports.resolveFileLines = resolveFileLines;
+exports.getCurrentBranch = getCurrentBranch;
+exports.findRepoRoot = findRepoRoot;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const GitNotes_1 = require("./GitNotes");
+// Origin precedence: ai=3, paste=2, user=1, existing=0
+const ORIGIN_PREC = { existing: 0, user: 1, paste: 2, ai: 3 };
+const ORIGIN_DECODE = ['existing', 'user', 'ai', 'paste'];
+const MIN_HINT_CHARLEN = 8;
+// ── FNV-1a 32-bit (matches extension's TypingTracker.hashLine) ───────────────
+function fnv1a(s) {
+    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;
+}
+// ── Merge helpers ─────────────────────────────────────────────────────────────
+/** Merge two HintMaps — higher precedence origin wins per hash. */
+function mergeHints(...maps) {
+    const out = 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.
+ */
+function hintsFromGitNotes(repoPath, relPath, absPath, maxCommits = 50) {
+    const map = new Map();
+    // Read current file to build hash→lineContent lookup
+    let fileLines;
+    try {
+        fileLines = fs.readFileSync(absPath, 'utf8').split('\n');
+    }
+    catch {
+        return map;
+    }
+    // Scan recent commits for a note that covers this file
+    let ranges;
+    try {
+        const log = (0, child_process_1.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 = (0, GitNotes_1.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).
+ */
+function lineMapFromOmni(repoPath, branch, relPath, currentLines) {
+    const result = new Map();
+    const omniPath = path.join(repoPath, '.omni');
+    if (!fs.existsSync(omniPath))
+        return result;
+    try {
+        const disk = 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();
+            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 = 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.
+ */
+function applyHints(stored, hints) {
+    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.modelDictionary = []);
+            stored.modelIds ?? (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.toolDictionary = []);
+            stored.toolIds ?? (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.
+ */
+function lineMapFromApiStored(stored, currentLines) {
+    return lineMapFromStoredInner(stored, currentLines);
+}
+function lineMapFromStoredInner(stored, currentLines) {
+    const result = new Map();
+    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();
+        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 = 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.
+ */
+async function resolveFileLinesAsync(repoPath, relPath, absPath, branch, projectName) {
+    let currentLines;
+    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 Promise.resolve().then(() => __importStar(require('./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, 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.
+ */
+function resolveFileLines(repoPath, relPath, absPath, branch) {
+    let currentLines;
+    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(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;
+}
+function getCurrentBranch(repoPath) {
+    try {
+        return (0, child_process_1.execFileSync)('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return 'main';
+    }
+}
+function findRepoRoot(startPath) {
+    try {
+        return (0, child_process_1.execFileSync)('git', ['-C', path.dirname(startPath), 'rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}