@aixle/insights 0.1.0

package/dist/readers/cursor.js

@@ -0,0 +1,900 @@
+/**
+ * Consolidated SQLite reader + ingest mapper for Cursor telemetry.
+ * Not imported from the package — public export is `./sync`.
+ */
+import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
+import { finished } from "node:stream/promises";
+import { createInterface } from "node:readline";
+import { createHash } from "node:crypto";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { glob } from "glob";
+import Database from "better-sqlite3";
+import { scanText } from "../risk-scanner.js";
+// ─── Reader: paths & SQLite ──────────────────────────────────────────────────
+export function cursorUserDir() {
+    switch (process.platform) {
+        case "darwin":
+            return join(homedir(), "Library", "Application Support", "Cursor", "User");
+        case "win32":
+            return join(process.env.APPDATA ?? homedir(), "Cursor", "User");
+        default:
+            return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "Cursor", "User");
+    }
+}
+function cursorProjectsDir() {
+    return join(homedir(), ".cursor", "projects");
+}
+const LEGACY_TABLE = "CursorRequestFeedback";
+const STATE_TABLE = "ItemTable";
+function getTableNames(db) {
+    return db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((r) => r.name);
+}
+function tableExists(db, tableName) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+        .get(tableName);
+    return row !== undefined;
+}
+function logDbTables(db, dbPath, label) {
+    const tables = getTableNames(db);
+    console.log(`  [${label}] ${dbPath}`);
+    console.log(`  tables: ${tables.join(", ") || "(none)"}`);
+}
+/** Smoke-test better-sqlite3 against the global Cursor state DB (CUR-V02 / verify scripts). */
+export function probeCursorGlobalStateDb(verbose = false) {
+    const dbPath = join(cursorUserDir(), "globalStorage", "state.vscdb");
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        const row = db
+            .prepare(`SELECT count(*) AS c FROM ${STATE_TABLE} WHERE key LIKE 'aiCodeTracking.dailyStats%'`)
+            .get();
+        db.close();
+        if (verbose) {
+            console.log(`  [probe] global state.vscdb OK — ${row.c} dailyStats key(s)`);
+        }
+        return true;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`  [probe] failed to read ${dbPath}: ${msg}`);
+        return false;
+    }
+}
+// ─── Legacy: cursor.db / CursorRequestFeedback ─────────────────────────────────
+export function findCursorDbs(baseDir) {
+    const dir = join(baseDir ?? cursorUserDir(), "workspaceStorage");
+    try {
+        return glob.sync(join(dir, "**", "cursor.db"));
+    }
+    catch {
+        return [];
+    }
+}
+function readLegacyFromDb(dbPath, since, workspacePath, verbose) {
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        if (verbose)
+            logDbTables(db, dbPath, "cursor.db");
+        if (!tableExists(db, LEGACY_TABLE))
+            return [];
+        const params = [workspacePath];
+        let query = `SELECT *, ? as _workspacePath FROM ${LEGACY_TABLE}`;
+        if (since != null) {
+            query += " WHERE timestamp > ?";
+            params.push(since.getTime() / 1000 - 1);
+        }
+        query += " ORDER BY timestamp ASC";
+        const rows = db.prepare(query).all(...params);
+        if (since != null) {
+            const sinceMs = since.getTime();
+            return rows.filter((row) => {
+                const ms = toEpochMs(row.timestamp);
+                return ms !== null && ms > sinceMs;
+            });
+        }
+        return rows;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+}
+export function readLegacyEvents(since, baseDir, verbose = false) {
+    const dbPaths = findCursorDbs(baseDir);
+    if (verbose)
+        console.log(`Found ${dbPaths.length} legacy cursor.db file(s)`);
+    const results = [];
+    for (const dbPath of dbPaths) {
+        const workspacePath = dbPath.replace(/[\\/]cursor\.db$/, "");
+        for (const row of readLegacyFromDb(dbPath, since, workspacePath, verbose)) {
+            results.push({ row, workspacePath });
+        }
+    }
+    return results;
+}
+export function isGlobalStateDbPath(dbPath) {
+    return dbPath.replace(/\\/g, "/").includes("/globalStorage/state.vscdb");
+}
+function fileUriToPath(uri) {
+    try {
+        if (uri.startsWith("file://"))
+            return fileURLToPath(uri);
+        return uri;
+    }
+    catch {
+        return null;
+    }
+}
+function readWorkspaceFolderFromJson(workspaceStorageDir) {
+    const jsonPath = join(workspaceStorageDir, "workspace.json");
+    if (!existsSync(jsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(jsonPath, "utf-8"));
+        if (typeof parsed.folder === "string")
+            return fileUriToPath(parsed.folder);
+        const folders = parsed.folders;
+        if (Array.isArray(folders) && folders.length > 0) {
+            const first = folders[0];
+            if (typeof first.path === "string")
+                return fileUriToPath(first.path);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function resolveCursorWorkspaceFolder(dbPathOrWorkspaceDir) {
+    if (isGlobalStateDbPath(dbPathOrWorkspaceDir))
+        return null;
+    const normalized = dbPathOrWorkspaceDir.replace(/\\/g, "/");
+    const wsDir = normalized.endsWith("/state.vscdb")
+        ? dirname(dbPathOrWorkspaceDir)
+        : dbPathOrWorkspaceDir;
+    return readWorkspaceFolderFromJson(wsDir);
+}
+function cursorWorkspaceMetadata(dbPath) {
+    const workspace_scope = isGlobalStateDbPath(dbPath) ? "global" : "workspace";
+    const folder = workspace_scope === "workspace" ? resolveCursorWorkspaceFolder(dbPath) : null;
+    return {
+        workspace: dbPath,
+        workspace_scope,
+        ...(folder ? { workspace_folder: folder } : {}),
+    };
+}
+function cursorWorkspaceMetadataFromStorageDir(workspaceStorageDir) {
+    const folder = resolveCursorWorkspaceFolder(workspaceStorageDir);
+    return {
+        workspace: workspaceStorageDir,
+        workspace_scope: "workspace",
+        ...(folder ? { workspace_folder: folder } : {}),
+    };
+}
+function dailyStatsActivityTotal(value) {
+    if (typeof value !== "object" || value === null)
+        return 0;
+    const o = value;
+    const fields = [
+        "tabSuggestedLines",
+        "tabAcceptedLines",
+        "composerSuggestedLines",
+        "composerAcceptedLines",
+    ];
+    return fields.reduce((sum, field) => {
+        const n = o[field];
+        return sum + (typeof n === "number" && n > 0 ? n : 0);
+    }, 0);
+}
+function dailyStatsValuesEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export function dedupeDailyStatsEntries(entries) {
+    const byDate = new Map();
+    for (const entry of entries) {
+        const group = byDate.get(entry.date) ?? [];
+        group.push(entry);
+        byDate.set(entry.date, group);
+    }
+    const deduped = [];
+    for (const group of byDate.values()) {
+        if (group.length === 1) {
+            deduped.push(group[0]);
+            continue;
+        }
+        const fromGlobal = group.filter((e) => isGlobalStateDbPath(e.dbPath));
+        if (fromGlobal.length > 0) {
+            deduped.push(fromGlobal[0]);
+            continue;
+        }
+        const distinct = [];
+        for (const entry of group) {
+            if (distinct.some((d) => dailyStatsValuesEqual(d.value, entry.value)))
+                continue;
+            distinct.push(entry);
+        }
+        if (distinct.length === 1) {
+            deduped.push(distinct[0]);
+            continue;
+        }
+        distinct.sort((a, b) => dailyStatsActivityTotal(b.value) - dailyStatsActivityTotal(a.value));
+        deduped.push(distinct[0]);
+    }
+    return deduped.sort((a, b) => a.date.localeCompare(b.date));
+}
+export function findStateVscDbs(baseDir) {
+    const userDir = baseDir ?? cursorUserDir();
+    const results = [];
+    results.push(join(userDir, "globalStorage", "state.vscdb"));
+    try {
+        results.push(...glob.sync(join(userDir, "workspaceStorage", "**", "state.vscdb")));
+    }
+    catch {
+        /* ignore */
+    }
+    return results;
+}
+function readDailyStatsFromDb(dbPath, since, verbose) {
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        if (verbose)
+            logDbTables(db, dbPath, "state.vscdb");
+        if (!tableExists(db, STATE_TABLE))
+            return [];
+        const rows = db
+            .prepare(`SELECT key, value FROM ${STATE_TABLE} WHERE key LIKE 'aiCodeTracking.%'`)
+            .all();
+        if (verbose && rows.length > 0) {
+            console.log(`  aiCodeTracking keys (${rows.length}):`);
+            for (const r of rows.slice(0, 10)) {
+                console.log(`    ${r.key} → ${r.value}`);
+            }
+            if (rows.length > 10)
+                console.log(`    … and ${rows.length - 10} more`);
+        }
+        const entries = [];
+        for (const { key, value: rawValue } of rows) {
+            const dateMatch = key.match(/(\d{4}-\d{2}-\d{2})$/);
+            if (!dateMatch)
+                continue;
+            const date = dateMatch[1];
+            if (since && date <= since.toISOString().slice(0, 10))
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(rawValue);
+            }
+            catch {
+                continue;
+            }
+            entries.push({ date, value: parsed, dbPath });
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+}
+function readDailyStatsRaw(since, baseDir, verbose) {
+    const dbPaths = findStateVscDbs(baseDir);
+    if (verbose) {
+        console.log(`Searching: ${baseDir ?? cursorUserDir()}`);
+        console.log(`Found ${dbPaths.length} state.vscdb file(s)`);
+    }
+    const raw = [];
+    for (const dbPath of dbPaths) {
+        raw.push(...readDailyStatsFromDb(dbPath, since, verbose));
+    }
+    return raw;
+}
+export function readDailyStatsWithDedupe(since, baseDir, verbose = false) {
+    const raw = readDailyStatsRaw(since, baseDir, verbose);
+    const deduped = dedupeDailyStatsEntries(raw);
+    if (verbose && raw.length !== deduped.length) {
+        console.log(`  dailyStats dedupe: ${raw.length} raw row(s) → ${deduped.length} after preferring globalStorage per date`);
+    }
+    return { raw, deduped };
+}
+export function readDailyStats(since, baseDir, verbose = false) {
+    return readDailyStatsWithDedupe(since, baseDir, verbose).deduped;
+}
+// ─── recentCommit ────────────────────────────────────────────────────────────
+const RECENT_COMMIT_KEY = "aiCodeTracking.recentCommit";
+function toTimestampMs(raw) {
+    if (typeof raw === "number" && !isNaN(raw) && raw > 0)
+        return raw;
+    if (typeof raw === "string") {
+        const n = Number(raw);
+        if (!isNaN(n) && n > 0)
+            return n;
+    }
+    return null;
+}
+function dedupeRecentCommitSnapshots(entries) {
+    const byKey = new Map();
+    for (const e of entries) {
+        const h = typeof e.value.commitHash === "string" && e.value.commitHash.length > 0
+            ? e.value.commitHash
+            : `${e.dbPath}:${String(e.value.timestamp ?? "")}`;
+        const prev = byKey.get(h);
+        const tE = toTimestampMs(e.value.timestamp);
+        if (tE === null)
+            continue;
+        if (!prev) {
+            byKey.set(h, e);
+            continue;
+        }
+        const tP = toTimestampMs(prev.value.timestamp);
+        if (tP === null || tE > tP)
+            byKey.set(h, e);
+    }
+    return [...byKey.values()];
+}
+function readRecentCommitFromDb(dbPath, since, verbose) {
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        if (!tableExists(db, STATE_TABLE))
+            return [];
+        const row = db
+            .prepare(`SELECT value FROM ${STATE_TABLE} WHERE key = ?`)
+            .get(RECENT_COMMIT_KEY);
+        if (!row)
+            return [];
+        let parsed;
+        try {
+            parsed = JSON.parse(row.value);
+        }
+        catch {
+            return [];
+        }
+        if (typeof parsed !== "object" || parsed === null)
+            return [];
+        const obj = parsed;
+        const tMs = toTimestampMs(obj.timestamp);
+        if (tMs === null)
+            return [];
+        if (since !== null) {
+            const sinceMs = since.getTime();
+            if (tMs <= sinceMs)
+                return [];
+        }
+        if (verbose) {
+            const ch = typeof obj.commitHash === "string" ? obj.commitHash : "";
+            console.log(`  [recentCommit] ${dbPath}`);
+            if (ch)
+                console.log(`    commitHash → ${ch.slice(0, 12)}…`);
+        }
+        return [{ value: obj, dbPath }];
+    }
+    catch {
+        return [];
+    }
+    finally {
+        db?.close();
+    }
+}
+export function readRecentCommitSnapshots(since, baseDir, verbose = false) {
+    const dbPaths = findStateVscDbs(baseDir);
+    if (verbose) {
+        console.log(`Searching recentCommit: ${baseDir ?? cursorUserDir()}`);
+    }
+    const found = [];
+    for (const dbPath of dbPaths) {
+        found.push(...readRecentCommitFromDb(dbPath, since, verbose));
+    }
+    return dedupeRecentCommitSnapshots(found);
+}
+export function readEvents(since, baseDir, verbose = false) {
+    return readLegacyEvents(since, baseDir, verbose);
+}
+function extractContentText(content) {
+    if (typeof content === "string")
+        return [content];
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((block) => {
+        if (typeof block !== "object" || block === null)
+            return [];
+        const { type, text } = block;
+        return type === "text" && typeof text === "string" ? [text] : [];
+    });
+}
+function stripUserQueryWrapper(text) {
+    return text
+        .replace(/<user_query>\s*/g, "")
+        .replace(/\s*<\/user_query>/g, "")
+        .trim();
+}
+function estimateTokens(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return 0;
+    return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+function toIsoFromMs(value) {
+    if (typeof value !== "number" || Number.isNaN(value) || value <= 0)
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function readComposerHeaders(baseDir) {
+    const userDir = baseDir ?? cursorUserDir();
+    const dbPath = join(userDir, "globalStorage", "state.vscdb");
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true });
+        if (!tableExists(db, STATE_TABLE))
+            return new Map();
+        const row = db
+            .prepare(`SELECT value FROM ${STATE_TABLE} WHERE key = ?`)
+            .get("composer.composerHeaders");
+        if (!row)
+            return new Map();
+        const parsed = JSON.parse(row.value);
+        if (typeof parsed !== "object" || parsed === null)
+            return new Map();
+        const allComposers = parsed.allComposers;
+        if (!Array.isArray(allComposers))
+            return new Map();
+        const headers = new Map();
+        for (const entry of allComposers) {
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const composer = entry;
+            const composerId = typeof composer.composerId === "string" && composer.composerId.length > 0
+                ? composer.composerId
+                : null;
+            if (!composerId)
+                continue;
+            const workspaceIdentifier = typeof composer.workspaceIdentifier === "object" && composer.workspaceIdentifier !== null
+                ? composer.workspaceIdentifier
+                : null;
+            const uri = workspaceIdentifier &&
+                typeof workspaceIdentifier.uri === "object" &&
+                workspaceIdentifier.uri !== null
+                ? workspaceIdentifier.uri
+                : null;
+            headers.set(composerId, {
+                composerId,
+                name: typeof composer.name === "string" ? composer.name : null,
+                workspacePath: typeof uri?.fsPath === "string" ? uri.fsPath : null,
+                lastUpdatedAt: toIsoFromMs(composer.lastUpdatedAt),
+            });
+        }
+        return headers;
+    }
+    catch {
+        return new Map();
+    }
+    finally {
+        db?.close();
+    }
+}
+export function findCursorTranscriptFiles(projectDirs) {
+    const dirs = projectDirs ?? [cursorProjectsDir()];
+    const files = [];
+    for (const dir of dirs) {
+        try {
+            files.push(...glob.sync("**/agent-transcripts/*/*.jsonl", {
+                cwd: dir,
+                absolute: true,
+            }));
+        }
+        catch {
+            // directory missing — skip
+        }
+    }
+    return [...new Set(files)];
+}
+/**
+ * Decode a Cursor project directory name back to the original workspace path.
+ * Cursor encodes workspace paths as `absolutePath.slice(1).replace(/\//g, '-')`,
+ * which is ambiguous when directories contain literal hyphens. We resolve the
+ * ambiguity by backtracking: at each '-', try treating it as a path separator
+ * first (only if the current prefix exists on disk), then as a literal hyphen.
+ */
+function decodeProjectDirName(encodedName) {
+    function bt(pos, current) {
+        if (pos === encodedName.length) {
+            return existsSync("/" + current) ? "/" + current : null;
+        }
+        const ch = encodedName[pos];
+        if (ch !== "-")
+            return bt(pos + 1, current + ch);
+        if (existsSync("/" + current)) {
+            const res = bt(pos + 1, current + "/");
+            if (res)
+                return res;
+        }
+        return bt(pos + 1, current + "-");
+    }
+    return bt(0, "");
+}
+/**
+ * Derive the workspace path from a transcript file path when the composer
+ * header doesn't carry a workspacePath. The transcript lives at:
+ *   ~/.cursor/projects/<encoded-workspace>/agent-transcripts/<session>/<session>.jsonl
+ * Going up three directories yields the encoded project dir, which we decode.
+ * Returns null on Windows (encoding differs) or if the path can't be resolved.
+ */
+function workspaceFromTranscriptFile(filePath) {
+    if (process.platform === "win32")
+        return null;
+    const projectDir = dirname(dirname(dirname(filePath)));
+    const projectsDir = cursorProjectsDir();
+    if (!projectDir.startsWith(projectsDir))
+        return null;
+    return decodeProjectDirName(basename(projectDir));
+}
+/** Skip JSONL files larger than this to avoid memory pressure on extremely long sessions. */
+const MAX_TRANSCRIPT_BYTES = 50 * 1024 * 1024; // 50 MB
+export async function parseCursorTranscriptFile(filePath, composerHeaders, verbose = false) {
+    let fileSize = 0;
+    let occurredAt = new Date().toISOString();
+    try {
+        const stat = statSync(filePath);
+        fileSize = stat.size;
+        occurredAt = stat.mtime.toISOString();
+    }
+    catch {
+        return [];
+    }
+    if (fileSize > MAX_TRANSCRIPT_BYTES) {
+        if (verbose) {
+            console.warn(`[warn][cursor] ${filePath} exceeds ${MAX_TRANSCRIPT_BYTES / 1024 / 1024} MB limit — skipping`);
+        }
+        return [];
+    }
+    const sessionId = basename(filePath, ".jsonl");
+    const header = composerHeaders.get(sessionId);
+    if (header?.lastUpdatedAt)
+        occurredAt = header.lastUpdatedAt;
+    const turns = [];
+    let currentPromptParts = [];
+    let currentAssistantParts = [];
+    let turnIndex = 0;
+    const hasher = createHash("sha256");
+    const stream = createReadStream(filePath, { encoding: "utf-8" });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    const finalizeTurn = () => {
+        const promptText = currentPromptParts.join("\n\n").trim();
+        const assistantText = currentAssistantParts.join("\n\n").trim();
+        if (!promptText && !assistantText)
+            return;
+        const risk = scanText(promptText);
+        turnIndex += 1;
+        turns.push({
+            turnId: `${sessionId}:${turnIndex}`,
+            sessionId,
+            filePath,
+            fileSize,
+            workspacePath: header?.workspacePath ?? workspaceFromTranscriptFile(filePath),
+            composerName: header?.name ?? null,
+            occurredAt,
+            promptText,
+            assistantText,
+            tokensIn: estimateTokens(promptText),
+            tokensOut: estimateTokens(assistantText),
+            riskLevel: risk.risk_level,
+            riskScore: risk.risk_score,
+            riskCategories: risk.risk_categories,
+        });
+    };
+    let lineNumber = 0;
+    try {
+        for await (const line of rl) {
+            lineNumber++;
+            hasher.update(line + "\n");
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                if (verbose) {
+                    console.warn(`[warn] ${filePath}:${lineNumber} — invalid JSON, skipping`);
+                }
+                continue;
+            }
+            const texts = extractContentText(entry.message?.content);
+            if (texts.length === 0)
+                continue;
+            if (entry.role === "user") {
+                if (currentPromptParts.length > 0 || currentAssistantParts.length > 0) {
+                    finalizeTurn();
+                    currentPromptParts = [];
+                    currentAssistantParts = [];
+                }
+                currentPromptParts.push(...texts.map(stripUserQueryWrapper).filter((text) => text.length > 0));
+            }
+            else if (entry.role === "assistant") {
+                currentAssistantParts.push(...texts.map((text) => text.trim()).filter((text) => text.length > 0));
+            }
+        }
+    }
+    catch (err) {
+        if (verbose) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(`[warn] ${filePath} — stream error, skipping file: ${message}`);
+        }
+        rl.close();
+        stream.destroy();
+        await finished(stream).catch(() => undefined);
+        return [];
+    }
+    finalizeTurn();
+    const contentHash = hasher.digest("hex").slice(0, 32);
+    for (const t of turns)
+        t.contentHash = contentHash;
+    return turns;
+}
+export async function readCursorTranscriptSessions(cursorUserBaseDir, transcriptProjectDirs, verbose = false) {
+    const composerHeaders = readComposerHeaders(cursorUserBaseDir);
+    const files = findCursorTranscriptFiles(transcriptProjectDirs);
+    const sessions = await Promise.all(files.map((filePath) => parseCursorTranscriptFile(filePath, composerHeaders, verbose)));
+    return sessions.flat();
+}
+// ─── Mapper ──────────────────────────────────────────────────────────────────
+const LINE_COST_MODEL = "estimated_line_count";
+const TOKEN_COST_MODEL = "token_count";
+const TRANSCRIPT_COST_MODEL = "estimated_transcript_text";
+export const HOOK_COST_MODEL = "cursor_hook";
+export const DEFAULT_CURSOR_PRICING = {
+    tokens_per_line: 15,
+    completion_output_per_mtok: 0.6,
+    chat_input_per_mtok: 3.0,
+    chat_output_per_mtok: 15.0,
+};
+const EPOCH_SECONDS_THRESHOLD = 1e12;
+export function toEpochMs(timestamp) {
+    if (timestamp == null)
+        return null;
+    const num = typeof timestamp === "string" ? Number(timestamp) : timestamp;
+    if (isNaN(num))
+        return null;
+    return num < EPOCH_SECONDS_THRESHOLD ? num * 1000 : num;
+}
+function toIsoString(timestamp) {
+    const ms = toEpochMs(timestamp);
+    if (ms === null)
+        return null;
+    const date = new Date(ms);
+    if (isNaN(date.getTime()))
+        return null;
+    return date.toISOString();
+}
+const nn = (n) => (n > 0 ? n : 0);
+function computeLineCost(eventType, lines, pricing) {
+    const safeLines = Math.max(0, lines);
+    const tokensPerLine = nn(pricing.tokens_per_line);
+    if (eventType === "completion") {
+        return (safeLines * tokensPerLine * nn(pricing.completion_output_per_mtok)) / 1_000_000;
+    }
+    return ((safeLines * tokensPerLine * (nn(pricing.chat_output_per_mtok) + nn(pricing.chat_input_per_mtok) * 2)) /
+        1_000_000);
+}
+function computeTokenCost(eventType, tokensIn, tokensOut, pricing) {
+    const safeIn = Math.max(0, tokensIn);
+    const safeOut = Math.max(0, tokensOut);
+    if (eventType === "completion") {
+        return (safeOut * nn(pricing.completion_output_per_mtok)) / 1_000_000;
+    }
+    return (safeIn * nn(pricing.chat_input_per_mtok) + safeOut * nn(pricing.chat_output_per_mtok)) / 1_000_000;
+}
+function pick(obj, ...keys) {
+    let cur = obj;
+    for (const k of keys) {
+        if (typeof cur !== "object" || cur === null)
+            return null;
+        cur = cur[k];
+    }
+    return typeof cur === "number" ? cur : null;
+}
+function buildPayload(opts) {
+    const { eventType, tokensIn, tokensOut, costUsd, occurredAt, dbPath, model = "unknown", projectId, costModel = LINE_COST_MODEL, } = opts;
+    const payload = {
+        tool_name: "cursor",
+        event_type: eventType,
+        model,
+        tokens_in: tokensIn,
+        tokens_out: tokensOut,
+        cost_usd: costUsd,
+        occurred_at: occurredAt,
+        metadata: {
+            cursor_session_id: null,
+            ...cursorWorkspaceMetadata(dbPath),
+            cost_model: costModel,
+            scannable: false,
+            risk_level: "none",
+        },
+    };
+    if (projectId)
+        payload.project_id = projectId;
+    return payload;
+}
+export function mapDailyStats(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+    const { date, value, dbPath } = entry;
+    const occurredAt = `${date}T00:00:00.000Z`;
+    const results = [];
+    if (typeof value !== "object" || value === null)
+        return results;
+    const obj = value;
+    const tabSuggested = pick(obj, "tabSuggestedLines") ?? 0;
+    const tabAccepted = pick(obj, "tabAcceptedLines") ?? 0;
+    const composerSuggested = pick(obj, "composerSuggestedLines") ?? 0;
+    const composerAccepted = pick(obj, "composerAcceptedLines") ?? 0;
+    if (tabSuggested > 0 || tabAccepted > 0) {
+        results.push(buildPayload({
+            eventType: "completion",
+            tokensIn: tabSuggested,
+            tokensOut: tabAccepted,
+            costUsd: computeLineCost("completion", tabSuggested, pricing),
+            occurredAt,
+            dbPath,
+            model,
+            projectId,
+        }));
+    }
+    if (composerSuggested > 0 || composerAccepted > 0) {
+        results.push(buildPayload({
+            eventType: "chat",
+            tokensIn: composerSuggested,
+            tokensOut: composerAccepted,
+            costUsd: computeLineCost("chat", composerSuggested, pricing),
+            occurredAt,
+            dbPath,
+            model,
+            projectId,
+        }));
+    }
+    if (results.length > 0)
+        return results;
+    const KNOWN_NON_MODEL_KEYS = new Set(["tab", "composer", "chat", "date", "inputTokens", "outputTokens"]);
+    for (const [model, stats] of Object.entries(obj)) {
+        if (KNOWN_NON_MODEL_KEYS.has(model) || typeof stats !== "object" || stats === null)
+            continue;
+        const tokensIn = pick(stats, "inputTokens") ?? pick(stats, "promptTokens") ?? 0;
+        const tokensOut = pick(stats, "outputTokens") ?? pick(stats, "generatedTokens") ?? 0;
+        if (tokensIn === 0 && tokensOut === 0)
+            continue;
+        results.push(buildPayload({
+            eventType: "chat",
+            tokensIn,
+            tokensOut,
+            costUsd: computeTokenCost("chat", tokensIn, tokensOut, pricing),
+            occurredAt,
+            dbPath,
+            model,
+            projectId,
+            costModel: TOKEN_COST_MODEL,
+        }));
+    }
+    return results;
+}
+/**
+ * Maps Cursor’s latest-commit snapshot (`aiCodeTracking.recentCommit`) to a single commit-classified event.
+ * Cursor only keeps one recent commit row (overwritten on each new commit).
+ * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
+ */
+export function mapRecentCommit(entry, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+    const { value: obj, dbPath } = entry;
+    const occurredAt = toIsoString(obj.timestamp);
+    if (!occurredAt)
+        return null;
+    const la = Number(obj.linesAdded) || 0;
+    const ld = Number(obj.linesDeleted) || 0;
+    const tla = Number(obj.tabLinesAdded) || 0;
+    const tld = Number(obj.tabLinesDeleted) || 0;
+    const cla = Number(obj.composerLinesAdded) || 0;
+    const cld = Number(obj.composerLinesDeleted) || 0;
+    const linesAddedProxy = la + tla + cla;
+    const linesDeletedProxy = ld + tld + cld;
+    if (linesAddedProxy === 0 && linesDeletedProxy === 0)
+        return null;
+    const lineForCost = linesAddedProxy + linesDeletedProxy;
+    const costUsd = computeLineCost("chat", Math.max(lineForCost, 0), pricing);
+    const commitHash = obj.commitHash;
+    const commitMessage = obj.commitMessage;
+    const repoName = obj.repoName;
+    const branchName = obj.branchName;
+    const aiPct = obj.aiPercentage;
+    const payload = {
+        tool_name: "cursor",
+        event_type: "commit",
+        model: model ?? "unknown",
+        tokens_in: linesAddedProxy,
+        tokens_out: linesDeletedProxy,
+        cost_usd: costUsd,
+        occurred_at: occurredAt,
+        metadata: {
+            cursor_session_id: null,
+            ...cursorWorkspaceMetadata(dbPath),
+            cost_model: LINE_COST_MODEL,
+            source: "recent_commit",
+            commit_hash: typeof commitHash === "string" ? commitHash : undefined,
+            commit_message: typeof commitMessage === "string" ? commitMessage : undefined,
+            repo_name: typeof repoName === "string" ? repoName : undefined,
+            branch_name: typeof branchName === "string" ? branchName : undefined,
+            ai_percentage: typeof aiPct === "number"
+                ? aiPct
+                : typeof aiPct === "string"
+                    ? parseFloat(aiPct) || undefined
+                    : undefined,
+            scannable: false,
+            risk_level: "none",
+        },
+    };
+    if (projectId)
+        payload.project_id = projectId;
+    return payload;
+}
+export function mapEvent(row, workspacePath, projectId, pricing = DEFAULT_CURSOR_PRICING) {
+    const occurredAt = toIsoString(row.timestamp);
+    if (!occurredAt)
+        return null;
+    const model = row.model;
+    if (!model)
+        return null;
+    const eventType = row.type === 1 ? "chat" : "completion";
+    const tokensIn = row.promptTokens ?? 0;
+    const tokensOut = row.generatedTokens ?? 0;
+    const payload = {
+        tool_name: "cursor",
+        event_type: eventType,
+        model,
+        tokens_in: tokensIn,
+        tokens_out: tokensOut,
+        cost_usd: computeTokenCost(eventType, tokensIn, tokensOut, pricing),
+        occurred_at: occurredAt,
+        metadata: {
+            cursor_session_id: row.sessionId ?? row.requestId ?? null,
+            ...cursorWorkspaceMetadataFromStorageDir(workspacePath),
+            cost_model: TOKEN_COST_MODEL,
+            scannable: false,
+            risk_level: "none",
+        },
+    };
+    if (projectId)
+        payload.project_id = projectId;
+    return payload;
+}
+export function mapTranscriptTurn(turn, projectId, pricing = DEFAULT_CURSOR_PRICING, model) {
+    const payload = {
+        tool_name: "cursor",
+        event_type: "chat",
+        model: model ?? "unknown",
+        tokens_in: turn.tokensIn,
+        tokens_out: turn.tokensOut,
+        cost_usd: computeTokenCost("chat", turn.tokensIn, turn.tokensOut, pricing),
+        occurred_at: turn.occurredAt,
+        metadata: {
+            session_id: turn.turnId,
+            cursor_session_id: turn.sessionId,
+            workspace: turn.workspacePath ?? turn.filePath,
+            cost_model: TRANSCRIPT_COST_MODEL,
+            scannable: true,
+            risk_level: turn.riskLevel,
+            risk_categories: turn.riskCategories,
+            risk_score: turn.riskScore,
+            transcript_source: "agent_transcript",
+            composer_name: turn.composerName ?? undefined,
+            prompt_text: turn.promptText || undefined,
+            assistant_text: turn.assistantText || undefined,
+        },
+    };
+    if (projectId)
+        payload.project_id = projectId;
+    return payload;
+}