@evomap/evolver-runtime-adapters 2.0.0-beta.0

package/dist/cursorState.d.ts

@@ -0,0 +1,9 @@
+import type { NormalizedSession } from './types.js';
+/**
+ * Read Cursor chat sessions out of a `state.vscdb` sqlite database (read-only). Returns one NormalizedSession per
+ * composer that has at least one real (non-meta) turn. Never throws on a malformed/locked db — returns []. The db
+ * is opened read-only, so it is safe to run against a live Cursor profile.
+ */
+export declare function parseCursorStateVscdb(dbPath: string): NormalizedSession[];
+/** True for a path that looks like a Cursor globalStorage state.vscdb. */
+export declare function isCursorStateVscdbPath(path: string): boolean;

package/dist/cursorState.js

@@ -0,0 +1,206 @@
+import { createRequire } from 'node:module';
+import { correlateToolNames, isMetaText } from './types.js';
+// node:sqlite is a recent Node built-in exposed only as `node:sqlite` (no bare `sqlite` alias). Load it through
+// createRequire so bundlers (vitest/vite) don't statically strip the prefix and fail resolution — mirrors the
+// pattern already used by evolver-core/src/mailbox/store.ts.
+const nodeRequire = createRequire(import.meta.url);
+// ── Cursor state.vscdb conversation extraction ───────────────────────────────
+//
+// VERIFICATION STATUS / COVERAGE (honest scope — read before extending):
+// Cursor stores chat in ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb (sqlite, can be
+// >1.85GB; node:sqlite opens it read-only with no CLI). Two tables: `ItemTable` (workbench KV) and
+// `cursorDiskKV` (the conversation store). The conversation lives in `cursorDiskKV` under these keys:
+//
+//   composerData:<composerId>  -> session header. Fields we rely on:
+//        { composerId, createdAt, unifiedMode, modelConfig:{modelName,...},
+//          fullConversationHeadersOnly: [ { bubbleId, type } ],   // ORDERED message list
+//          conversationMap?: { <bubbleId>: <bubble> } }           // sometimes inlined
+//   bubbleId:<composerId>:<bubbleId>  -> a single message bubble (when not inlined in conversationMap).
+//
+// A bubble:
+//   { type: 1|2, text, richText?, thinking?:{text}|string, toolFormerData?:{name,rawArgs|params,result},
+//     tokenCount?:{inputTokens,outputTokens} }
+//   type === 1 -> user, type === 2 -> assistant. (Cursor's MessageType enum.)
+//
+// COVERED here: opening the db read-only; enumerating composers; ordering messages by
+// fullConversationHeadersOnly; reading bubbles from BOTH the inlined conversationMap and the separate
+// bubbleId:<composer>:<bubble> rows; extracting user/assistant text, assistant `thinking` as a reasoning turn,
+// and `toolFormerData` as a tool_use + tool_result pair; per-bubble token counts; session model/createdAt.
+//
+// NOT yet covered / known gaps (the local machine's DB had only EMPTY composers, so these are schema-documented
+// but not golden-verified against real populated bubbles): Cursor's code-edit "diff" capability blocks
+// (codeBlockData / originalFileStates) are NOT reconstructed into before/after diffs; sub-composer / best-of-N
+// branch bubbles are read flat (no tree structure); attachment/context payloads are ignored. Extend with a real
+// populated-DB fixture before trusting those.
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function asString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function bubbleThinkingText(bubble) {
+    const thinking = bubble['thinking'];
+    if (typeof thinking === 'string')
+        return thinking;
+    if (isRecord(thinking)) {
+        const text = thinking['text'] ?? thinking['content'];
+        if (typeof text === 'string')
+            return text;
+    }
+    return '';
+}
+function bubbleToolTurns(bubble, toolUseId) {
+    const tool = bubble['toolFormerData'];
+    if (!isRecord(tool))
+        return [];
+    const name = asString(tool['name']) || asString(tool['tool']) || 'unknown';
+    const rawArgs = tool['rawArgs'] ?? tool['params'] ?? tool['args'];
+    const result = tool['result'];
+    const turns = [{
+            role: 'assistant',
+            text: '',
+            toolName: name,
+            toolUseId,
+            ...(rawArgs !== undefined ? { toolInput: rawArgs } : {}),
+            isMeta: false,
+        }];
+    if (result !== undefined) {
+        const resultText = typeof result === 'string' ? result : JSON.stringify(result);
+        turns.push({
+            role: 'tool',
+            text: '',
+            toolName: name,
+            toolUseId,
+            toolResult: resultText,
+            isMeta: false,
+        });
+    }
+    return turns;
+}
+function bubbleToTurns(bubble, bubbleId) {
+    if (!isRecord(bubble))
+        return [];
+    const type = finiteNumber(bubble['type']);
+    const inputTokens = isRecord(bubble['tokenCount']) ? finiteNumber(bubble['tokenCount']['inputTokens']) : undefined;
+    const outputTokens = isRecord(bubble['tokenCount']) ? finiteNumber(bubble['tokenCount']['outputTokens']) : undefined;
+    const text = asString(bubble['text']);
+    const turns = [];
+    if (type === 1) {
+        // user bubble
+        turns.push({ role: 'user', text, isMeta: isMetaText(text) });
+        return turns;
+    }
+    // assistant (type === 2) or unknown -> treat as assistant content
+    const thinking = bubbleThinkingText(bubble);
+    if (thinking) {
+        turns.push({ role: 'assistant', text: thinking, reasoning: true, isMeta: false });
+    }
+    if (text) {
+        turns.push({
+            role: 'assistant',
+            text,
+            ...(inputTokens !== undefined ? { inputTokens } : {}),
+            ...(outputTokens !== undefined ? { outputTokens } : {}),
+            isMeta: isMetaText(text),
+        });
+    }
+    turns.push(...bubbleToolTurns(bubble, bubbleId));
+    return turns;
+}
+function conversationHeaders(composer) {
+    const headers = composer['fullConversationHeadersOnly'];
+    if (!Array.isArray(headers))
+        return [];
+    return headers
+        .map((header) => (isRecord(header) ? { bubbleId: asString(header['bubbleId']), type: finiteNumber(header['type']) } : { bubbleId: '' }))
+        .filter((header) => header.bubbleId);
+}
+function composerToSession(composer, composerId, readBubble) {
+    const headers = conversationHeaders(composer);
+    const conversationMap = isRecord(composer['conversationMap']) ? composer['conversationMap'] : undefined;
+    const orderedBubbleIds = headers.length > 0
+        ? headers.map((header) => header.bubbleId)
+        : (conversationMap ? Object.keys(conversationMap) : []);
+    const turns = [];
+    for (const bubbleId of orderedBubbleIds) {
+        const bubble = (conversationMap && conversationMap[bubbleId] !== undefined)
+            ? conversationMap[bubbleId]
+            : readBubble(composerId, bubbleId);
+        turns.push(...bubbleToTurns(bubble, bubbleId));
+    }
+    const model = isRecord(composer['modelConfig']) ? asString(composer['modelConfig']['modelName']) : '';
+    const createdAt = finiteNumber(composer['createdAt']);
+    return {
+        turns: correlateToolNames(turns),
+        sessionId: composerId,
+        provider: 'cursor',
+        ...(model ? { model } : {}),
+        ...(createdAt !== undefined ? { startedAt: new Date(createdAt).toISOString() } : {}),
+        clientSource: 'cursor',
+        sourceRecord: { composerId, ...(model ? { model } : {}) },
+    };
+}
+/**
+ * Read Cursor chat sessions out of a `state.vscdb` sqlite database (read-only). Returns one NormalizedSession per
+ * composer that has at least one real (non-meta) turn. Never throws on a malformed/locked db — returns []. The db
+ * is opened read-only, so it is safe to run against a live Cursor profile.
+ */
+export function parseCursorStateVscdb(dbPath) {
+    let db;
+    try {
+        const { DatabaseSync } = nodeRequire('node:sqlite');
+        db = new DatabaseSync(dbPath, { readOnly: true });
+        const composerRows = db
+            .prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
+            .all();
+        const bubbleStmt = db.prepare('SELECT value FROM cursorDiskKV WHERE key = ?');
+        const readBubble = (composerId, bubbleId) => {
+            try {
+                const row = bubbleStmt.get(`bubbleId:${composerId}:${bubbleId}`);
+                if (!row || typeof row.value !== 'string')
+                    return undefined;
+                return JSON.parse(row.value);
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const sessions = [];
+        for (const row of composerRows) {
+            if (typeof row.value !== 'string')
+                continue;
+            let composer;
+            try {
+                composer = JSON.parse(row.value);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(composer))
+                continue;
+            const composerId = asString(row.key).replace(/^composerData:/, '') || asString(composer['composerId']);
+            const session = composerToSession(composer, composerId, readBubble);
+            if (session.turns.some((turn) => turn.isMeta !== true))
+                sessions.push(session);
+        }
+        return sessions;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch {
+            /* ignore close errors */
+        }
+    }
+}
+/** True for a path that looks like a Cursor globalStorage state.vscdb. */
+export function isCursorStateVscdbPath(path) {
+    return /(^|[/\\])state\.vscdb$/i.test(path) && /[/\\]Cursor[/\\]/i.test(path);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGE = "@evomap/evolver-runtime-adapters";
+export * from './types.js';
+export * from './adapters.js';
+export * from './cursorState.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export const PACKAGE = '@evomap/evolver-runtime-adapters';
+export * from './types.js';
+export * from './adapters.js';
+export * from './cursorState.js';

package/dist/types.d.ts

@@ -0,0 +1,96 @@
+export interface NormalizedTurn {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    text: string;
+    timestamp?: string;
+    model?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    toolName?: string;
+    toolInput?: unknown;
+    /** Anthropic content blocks carry the tool name on tool_use and reference it by id on tool_result;
+     *  this id lets us correlate the two so a failing tool_result can be attributed to its tool. */
+    toolUseId?: string;
+    toolResult?: string;
+    errorMessage?: string;
+    reasoning?: boolean;
+    /** A thinking block that was present in the source but carried no text AND no signature/encrypted payload.
+     *  We KEEP the turn (instead of silently dropping it) and flag it so buyers can tell "the model emitted an
+     *  empty thinking block" apart from "we dropped the reasoning during collection". */
+    thinkingEmpty?: boolean;
+    reasoningSignature?: string;
+    encryptedSignature?: string;
+    encryptedContent?: unknown;
+    sourceRecord?: unknown;
+    rawRow?: unknown;
+    metadata?: unknown;
+    usage?: unknown;
+    risk?: unknown;
+    fidelity?: unknown;
+    confidentiality?: unknown;
+    isMeta: boolean;
+}
+export interface NormalizedNativeCall {
+    provider?: string;
+    timestamp?: string;
+    request_time?: string;
+    response_time?: string;
+    ttfb_ms?: number;
+    request_headers?: unknown;
+    response_headers?: unknown;
+    transport?: unknown;
+    transport_metadata?: unknown;
+    request_body?: unknown;
+    response_body?: unknown;
+    metadata?: unknown;
+    usage?: unknown;
+    risk?: unknown;
+    fidelity?: unknown;
+    confidentiality?: unknown;
+    sourceRecord?: unknown;
+    rawRow?: unknown;
+}
+export interface NormalizedSession {
+    turns: NormalizedTurn[];
+    sessionId?: string;
+    provider?: string;
+    model?: string;
+    tools?: unknown;
+    startedAt?: string;
+    nativeCalls?: NormalizedNativeCall[];
+    clientSource?: string;
+    systemPrompt?: string;
+    metadata?: unknown;
+    usage?: unknown;
+    risk?: unknown;
+    fidelity?: unknown;
+    confidentiality?: unknown;
+    sourceRecord?: unknown;
+    rawRows?: unknown[];
+}
+export interface SessionLogAdapter {
+    readonly agent: string;
+    detect(path: string): boolean;
+    parse(rawChunk: string): NormalizedTurn[];
+    parseSession?(rawChunk: string): NormalizedSession;
+    parseSessions?(rawChunk: string): NormalizedSession[];
+}
+export interface JsonlParseStats {
+    rowsScanned: number;
+    rowsRead: number;
+    invalidJson: number;
+}
+export declare const META_MARKERS: string[];
+export declare function isMetaText(text: string): boolean;
+export declare function parseJsonlLinesWithStats(chunk: string): {
+    rows: Record<string, unknown>[];
+    stats: JsonlParseStats;
+};
+export declare function parseJsonlLines(chunk: string): Record<string, unknown>[];
+/** content: string | array of {type:text|tool_use|tool_result} → NormalizedTurn[]. */
+export declare function extractContent(role: NormalizedTurn['role'], content: unknown): NormalizedTurn[];
+/**
+ * Backfill toolName onto tool_result turns by correlating tool_use_id → the originating tool_use's name.
+ * Anthropic content blocks only name the tool on tool_use; the tool_result references it by id, so without
+ * this a failing tool_result has no tool attribution. No-op for turns that carry no toolUseId.
+ */
+export declare function correlateToolNames(turns: NormalizedTurn[]): NormalizedTurn[];

package/dist/types.js

@@ -0,0 +1,101 @@
+export const META_MARKERS = ['HEARTBEAT_OK', 'NO_REPLY', 'NO_RESPONSE_NEEDED', '[META]'];
+export function isMetaText(text) {
+    const t = text.trim();
+    return t.length === 0 || META_MARKERS.some((m) => t === m || t.startsWith(m));
+}
+export function parseJsonlLinesWithStats(chunk) {
+    const out = [];
+    const stats = { rowsScanned: 0, rowsRead: 0, invalidJson: 0 };
+    for (const l of chunk.split('\n')) {
+        if (!l.trim())
+            continue;
+        stats.rowsScanned += 1;
+        try {
+            const o = JSON.parse(l);
+            if (o && typeof o === 'object') {
+                out.push(o);
+                stats.rowsRead += 1;
+            }
+        }
+        catch {
+            stats.invalidJson += 1;
+        }
+    }
+    return { rows: out, stats };
+}
+export function parseJsonlLines(chunk) {
+    return parseJsonlLinesWithStats(chunk).rows;
+}
+function stringifyResult(c) {
+    if (typeof c === 'string')
+        return c;
+    if (Array.isArray(c))
+        return c.map((x) => (typeof x === 'string' ? x : x['text'] ?? JSON.stringify(x))).join('\n');
+    return JSON.stringify(c);
+}
+/** content: string | array of {type:text|tool_use|tool_result} → NormalizedTurn[]. */
+export function extractContent(role, content) {
+    if (typeof content === 'string')
+        return [{ role, text: content, isMeta: isMetaText(content) }];
+    if (!Array.isArray(content))
+        return [];
+    const turns = [];
+    for (const part of content) {
+        if (!part || typeof part !== 'object')
+            continue;
+        const p = part;
+        const ptype = p['type'];
+        if (ptype === 'text' && typeof p['text'] === 'string')
+            turns.push({ role, text: p['text'], isMeta: isMetaText(p['text']) });
+        else if (ptype === 'thinking') {
+            const text = typeof p['thinking'] === 'string' ? p['thinking'] : (typeof p['text'] === 'string' ? p['text'] : '');
+            const reasoningSignature = typeof p['signature'] === 'string' ? p['signature'] : undefined;
+            const encryptedSignature = typeof p['encrypted_signature'] === 'string'
+                ? p['encrypted_signature']
+                : (typeof p['encryptedSignature'] === 'string' ? p['encryptedSignature'] : undefined);
+            const encryptedContent = p['encrypted_content'] ?? p['encryptedContent'];
+            // Previously an empty thinking block (no text, no signature, no encrypted payload) was dropped entirely,
+            // which made "model thought nothing" indistinguishable from "we lost the reasoning". Keep it and flag it.
+            const isEmptyThinking = !text && !reasoningSignature && !encryptedSignature && encryptedContent === undefined;
+            turns.push({
+                role: 'assistant',
+                text,
+                reasoning: true,
+                ...(isEmptyThinking ? { thinkingEmpty: true } : {}),
+                ...(reasoningSignature ? { reasoningSignature } : {}),
+                ...(encryptedSignature ? { encryptedSignature } : {}),
+                ...(encryptedContent !== undefined ? { encryptedContent } : {}),
+                isMeta: false,
+            });
+        }
+        else if (ptype === 'tool_use') {
+            turns.push({
+                role: 'assistant',
+                text: '',
+                toolName: String(p['name'] ?? ''),
+                ...(p['id'] ? { toolUseId: String(p['id']) } : {}),
+                ...(p['input'] !== undefined ? { toolInput: p['input'] } : {}),
+                isMeta: false,
+            });
+        }
+        else if (ptype === 'tool_result') {
+            const r = stringifyResult(p['content']);
+            turns.push({ role: 'tool', text: '', toolResult: r, ...(p['tool_use_id'] ? { toolUseId: String(p['tool_use_id']) } : {}), ...(p['is_error'] ? { errorMessage: r } : {}), isMeta: false });
+        }
+    }
+    return turns;
+}
+/**
+ * Backfill toolName onto tool_result turns by correlating tool_use_id → the originating tool_use's name.
+ * Anthropic content blocks only name the tool on tool_use; the tool_result references it by id, so without
+ * this a failing tool_result has no tool attribution. No-op for turns that carry no toolUseId.
+ */
+export function correlateToolNames(turns) {
+    const nameById = new Map();
+    for (const t of turns)
+        if (t.toolUseId && t.toolName)
+            nameById.set(t.toolUseId, t.toolName);
+    if (nameById.size === 0)
+        return turns;
+    return turns.map((t) => (!t.toolName && t.toolUseId && nameById.has(t.toolUseId) ? { ...t, toolName: nameById.get(t.toolUseId) } : t));
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@evomap/evolver-runtime-adapters",
+  "version": "2.0.0-beta.0",
+  "private": false,
+  "type": "module",
+  "description": "五 runtime 会话日志适配器 (CC/codex/cursor/kiro/opencode)",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "v2-beta"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "package.json"
+  ]
+}