braindump 0.3.0

package/dist/adapters/cursor/adapter.js

@@ -0,0 +1,675 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createHash } from "node:crypto";
+import Database from "better-sqlite3";
+import { BaseAdapter } from "../base-adapter.js";
+import { analyzeConversation } from "../../core/conversation-analyzer.js";
+import { extractProjectContext } from "../../core/project-context.js";
+import { validateSession } from "../../core/validation.js";
+/**
+ * Adapter for Cursor sessions.
+ * Reads SQLite databases from workspaceStorage/<hash>/state.vscdb
+ */
+export class CursorAdapter extends BaseAdapter {
+    agentId = "cursor";
+    get workspaceStorageDir() {
+        if (process.platform === "darwin") {
+            return path.join(os.homedir(), "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+        }
+        if (process.platform === "linux") {
+            return path.join(os.homedir(), ".config", "Cursor", "User", "workspaceStorage");
+        }
+        const appData = process.env.APPDATA ||
+            path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(appData, "Cursor", "User", "workspaceStorage");
+    }
+    async detect() {
+        if (!fs.existsSync(this.workspaceStorageDir)) {
+            return false;
+        }
+        const entries = fs.readdirSync(this.workspaceStorageDir, {
+            withFileTypes: true,
+        });
+        return entries.some((entry) => {
+            if (!entry.isDirectory()) {
+                return false;
+            }
+            const dbPath = path.join(this.workspaceStorageDir, entry.name, "state.vscdb");
+            return fs.existsSync(dbPath);
+        });
+    }
+    async listSessions(projectPath) {
+        if (!fs.existsSync(this.workspaceStorageDir)) {
+            return [];
+        }
+        const sessions = [];
+        const workspaceEntries = fs
+            .readdirSync(this.workspaceStorageDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory());
+        const candidates = [];
+        for (const workspaceEntry of workspaceEntries) {
+            const workspaceHash = workspaceEntry.name;
+            const workspaceDir = path.join(this.workspaceStorageDir, workspaceHash);
+            const dbPath = path.join(workspaceDir, "state.vscdb");
+            if (!fs.existsSync(dbPath)) {
+                continue;
+            }
+            const resolvedProjectPath = this.readWorkspaceProjectPath(workspaceDir);
+            const stat = fs.statSync(dbPath);
+            candidates.push({
+                workspaceHash,
+                workspaceDir,
+                dbPath,
+                resolvedProjectPath,
+                mtimeMs: stat.mtimeMs,
+            });
+        }
+        if (candidates.length === 0) {
+            return [];
+        }
+        let selectedCandidates = candidates;
+        if (projectPath) {
+            const exactMatches = candidates.filter((candidate) => candidate.resolvedProjectPath &&
+                this.pathsEqual(projectPath, candidate.resolvedProjectPath));
+            const hashMatches = candidates.filter((candidate) => this.matchesWorkspaceHash(projectPath, candidate.workspaceHash));
+            if (exactMatches.length > 0) {
+                selectedCandidates = exactMatches;
+            }
+            else if (hashMatches.length > 0) {
+                selectedCandidates = hashMatches;
+            }
+            else {
+                const fallback = [...candidates].sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
+                selectedCandidates = fallback ? [fallback] : [];
+            }
+        }
+        for (const candidate of selectedCandidates) {
+            let db = null;
+            try {
+                db = this.openDatabase(candidate.dbPath);
+                const composers = this.readComposers(db);
+                for (const composer of composers) {
+                    sessions.push({
+                        id: `${candidate.workspaceHash}:${composer.id}`,
+                        startedAt: composer.startedAt,
+                        lastActiveAt: composer.lastActiveAt,
+                        messageCount: composer.messageCount,
+                        projectPath: candidate.resolvedProjectPath ??
+                            (projectPath && this.matchesWorkspaceHash(projectPath, candidate.workspaceHash)
+                                ? projectPath
+                                : undefined),
+                        preview: composer.preview,
+                    });
+                }
+            }
+            catch {
+                // Skip unreadable workspace DBs.
+            }
+            finally {
+                db?.close();
+            }
+        }
+        sessions.sort((a, b) => {
+            const aTime = a.lastActiveAt || a.startedAt || "";
+            const bTime = b.lastActiveAt || b.startedAt || "";
+            return bTime.localeCompare(aTime);
+        });
+        return sessions;
+    }
+    async capture(sessionId) {
+        const separator = sessionId.indexOf(":");
+        if (separator <= 0) {
+            throw new Error(`Invalid Cursor session ID: ${sessionId}. Expected <workspace-hash>:<composer-id>`);
+        }
+        const workspaceHash = sessionId.slice(0, separator);
+        const composerId = sessionId.slice(separator + 1);
+        const workspaceDir = path.join(this.workspaceStorageDir, workspaceHash);
+        const dbPath = path.join(workspaceDir, "state.vscdb");
+        if (!fs.existsSync(dbPath)) {
+            throw new Error(`Cursor workspace DB not found: ${dbPath}`);
+        }
+        const projectPath = this.readWorkspaceProjectPath(workspaceDir) || process.cwd();
+        const messages = [];
+        const fileChanges = new Map();
+        let totalTokens = 0;
+        let sessionStartedAt;
+        let lastAssistantMessage = "";
+        const db = this.openDatabase(dbPath);
+        try {
+            const bubbleRows = this.readBubbleRows(db, composerId);
+            for (const row of bubbleRows) {
+                const parsed = this.parseCursorPayload(row.value);
+                if (parsed.message) {
+                    messages.push(parsed.message);
+                    if (!sessionStartedAt && parsed.message.timestamp) {
+                        sessionStartedAt = parsed.message.timestamp;
+                    }
+                    if (parsed.message.role === "assistant") {
+                        lastAssistantMessage = parsed.message.content;
+                    }
+                }
+                for (const toolMessage of parsed.toolMessages) {
+                    messages.push(toolMessage);
+                }
+                for (const change of parsed.fileChanges) {
+                    fileChanges.set(change.path, change);
+                }
+                totalTokens += parsed.tokenCount;
+            }
+            if (messages.length === 0) {
+                const composerData = this.getJsonValue(db, `composerData:${composerId}`);
+                const fallbackPayloads = this.extractMessagesFromComposerData(composerData, composerId);
+                for (const payload of fallbackPayloads) {
+                    const parsed = this.parseCursorPayload(payload);
+                    if (parsed.message) {
+                        messages.push(parsed.message);
+                        if (!sessionStartedAt && parsed.message.timestamp) {
+                            sessionStartedAt = parsed.message.timestamp;
+                        }
+                        if (parsed.message.role === "assistant") {
+                            lastAssistantMessage = parsed.message.content;
+                        }
+                    }
+                    for (const toolMessage of parsed.toolMessages) {
+                        messages.push(toolMessage);
+                    }
+                    for (const change of parsed.fileChanges) {
+                        fileChanges.set(change.path, change);
+                    }
+                    totalTokens += parsed.tokenCount;
+                }
+            }
+            if (messages.length === 0) {
+                const legacy = this.getJsonValue(db, "workbench.panel.aichat.view.aichat.chatdata");
+                const legacyPayloads = this.extractMessagesFromLegacy(legacy, composerId);
+                for (const payload of legacyPayloads) {
+                    const parsed = this.parseCursorPayload(payload);
+                    if (parsed.message) {
+                        messages.push(parsed.message);
+                        if (!sessionStartedAt && parsed.message.timestamp) {
+                            sessionStartedAt = parsed.message.timestamp;
+                        }
+                        if (parsed.message.role === "assistant") {
+                            lastAssistantMessage = parsed.message.content;
+                        }
+                    }
+                    for (const toolMessage of parsed.toolMessages) {
+                        messages.push(toolMessage);
+                    }
+                    for (const change of parsed.fileChanges) {
+                        fileChanges.set(change.path, change);
+                    }
+                    totalTokens += parsed.tokenCount;
+                }
+            }
+        }
+        finally {
+            db.close();
+        }
+        messages.sort((a, b) => {
+            const aTime = a.timestamp || "";
+            const bTime = b.timestamp || "";
+            return aTime.localeCompare(bTime);
+        });
+        const projectContext = await extractProjectContext(projectPath);
+        const analysis = analyzeConversation(messages);
+        const session = {
+            version: "1.0",
+            source: "cursor",
+            capturedAt: new Date().toISOString(),
+            sessionId,
+            sessionStartedAt,
+            project: {
+                ...projectContext,
+                path: projectContext.path || projectPath,
+                name: projectContext.name || path.basename(projectPath),
+            },
+            conversation: {
+                messageCount: messages.length,
+                estimatedTokens: totalTokens,
+                messages,
+            },
+            filesChanged: Array.from(fileChanges.values()),
+            decisions: analysis.decisions,
+            blockers: analysis.blockers,
+            task: {
+                description: analysis.taskDescription,
+                completed: analysis.completedSteps,
+                remaining: [],
+                inProgress: lastAssistantMessage
+                    ? lastAssistantMessage.substring(0, 200)
+                    : undefined,
+                blockers: analysis.blockers,
+            },
+        };
+        return validateSession(session);
+    }
+    async captureLatest(projectPath) {
+        const sessions = await this.listSessions(projectPath);
+        if (sessions.length === 0) {
+            throw new Error(projectPath
+                ? `No Cursor sessions found for project: ${projectPath}`
+                : "No Cursor sessions found");
+        }
+        return this.capture(sessions[0].id);
+    }
+    openDatabase(dbPath) {
+        return new Database(dbPath, { readonly: true, fileMustExist: true });
+    }
+    getAvailableTables(db) {
+        const rows = db
+            .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name IN ('ItemTable', 'cursorDiskKV')")
+            .all();
+        return rows.map((row) => row.name);
+    }
+    getValue(db, key) {
+        for (const table of this.getAvailableTables(db)) {
+            const row = db
+                .prepare(`SELECT value FROM ${table} WHERE key = ? LIMIT 1`)
+                .get(key);
+            if (row?.value != null) {
+                return row.value;
+            }
+        }
+        return null;
+    }
+    getJsonValue(db, key) {
+        const raw = this.getValue(db, key);
+        if (!raw) {
+            return null;
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    readBubbleRows(db, composerId) {
+        const rows = [];
+        for (const table of this.getAvailableTables(db)) {
+            const results = db
+                .prepare(`SELECT key, value FROM ${table} WHERE key LIKE ? ORDER BY key`)
+                .all(`bubbleId:${composerId}:%`);
+            for (const row of results) {
+                try {
+                    rows.push({ key: row.key, value: JSON.parse(row.value) });
+                }
+                catch {
+                    // Skip malformed rows.
+                }
+            }
+        }
+        return rows;
+    }
+    readComposers(db) {
+        const modern = this.getJsonValue(db, "composer.composerData");
+        const modernComposers = this.normalizeComposerEntries(modern);
+        if (modernComposers.length > 0) {
+            return modernComposers;
+        }
+        const legacy = this.getJsonValue(db, "workbench.panel.aichat.view.aichat.chatdata");
+        return this.normalizeComposerEntries(legacy);
+    }
+    normalizeComposerEntries(payload) {
+        const items = this.findComposerArray(payload);
+        const composers = [];
+        for (const item of items) {
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            const candidate = item;
+            const id = candidate.composerId ||
+                candidate.id ||
+                candidate.uuid;
+            if (!id) {
+                continue;
+            }
+            const preview = candidate.preview ||
+                candidate.title ||
+                candidate.initialPrompt ||
+                candidate.lastMessagePreview;
+            composers.push({
+                id,
+                startedAt: this.normalizeTimestamp(candidate.createdAt ??
+                    candidate.startedAt ??
+                    candidate.firstMessageAt ??
+                    candidate.timestamp),
+                lastActiveAt: this.normalizeTimestamp(candidate.lastUpdatedAt ??
+                    candidate.lastActiveAt ??
+                    candidate.updatedAt ??
+                    candidate.timestamp),
+                messageCount: this.normalizeNumber(candidate.messageCount ??
+                    (Array.isArray(candidate.messages) ? candidate.messages.length : undefined)),
+                preview,
+            });
+        }
+        return composers;
+    }
+    findComposerArray(payload) {
+        if (Array.isArray(payload)) {
+            return payload;
+        }
+        if (!payload || typeof payload !== "object") {
+            return [];
+        }
+        const obj = payload;
+        if (Array.isArray(obj.allComposers)) {
+            return obj.allComposers;
+        }
+        if (Array.isArray(obj.composers)) {
+            return obj.composers;
+        }
+        if (Array.isArray(obj.sessions)) {
+            return obj.sessions;
+        }
+        if (Array.isArray(obj.chats)) {
+            return obj.chats;
+        }
+        return [];
+    }
+    extractMessagesFromComposerData(payload, composerId) {
+        if (!payload || typeof payload !== "object") {
+            return [];
+        }
+        const obj = payload;
+        if (Array.isArray(obj.messages)) {
+            return obj.messages;
+        }
+        if (Array.isArray(obj.bubbles)) {
+            return obj.bubbles;
+        }
+        if (Array.isArray(obj.composers) ||
+            Array.isArray(obj.allComposers) ||
+            Array.isArray(obj.sessions)) {
+            const composers = this.findComposerArray(obj);
+            for (const entry of composers) {
+                if (!entry || typeof entry !== "object") {
+                    continue;
+                }
+                const composer = entry;
+                const id = composer.composerId ||
+                    composer.id;
+                if (id !== composerId) {
+                    continue;
+                }
+                if (Array.isArray(composer.messages)) {
+                    return composer.messages;
+                }
+                if (Array.isArray(composer.bubbles)) {
+                    return composer.bubbles;
+                }
+            }
+        }
+        return [];
+    }
+    extractMessagesFromLegacy(payload, composerId) {
+        if (!payload || typeof payload !== "object") {
+            return [];
+        }
+        const obj = payload;
+        const containers = this.findComposerArray(obj);
+        for (const entry of containers) {
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const session = entry;
+            const id = session.composerId ||
+                session.id;
+            if (id && id !== composerId) {
+                continue;
+            }
+            if (Array.isArray(session.messages)) {
+                return session.messages;
+            }
+            if (Array.isArray(session.bubbles)) {
+                return session.bubbles;
+            }
+        }
+        return [];
+    }
+    parseCursorPayload(payload) {
+        if (!payload || typeof payload !== "object") {
+            return { toolMessages: [], fileChanges: [], tokenCount: 0 };
+        }
+        const obj = payload;
+        const timestamp = this.normalizeTimestamp(obj.timestamp ?? obj.createdAt ?? obj.time);
+        const tokenCount = this.normalizeNumber(obj.tokenCount ??
+            (obj.usage && typeof obj.usage === "object"
+                ? obj.usage.total_tokens
+                : undefined)) || 0;
+        const role = this.mapRole(obj.role ||
+            obj.type ||
+            obj.sender);
+        const text = this.extractText(obj);
+        const parsed = {
+            toolMessages: [],
+            fileChanges: [],
+            tokenCount,
+        };
+        if (text) {
+            parsed.message = {
+                role,
+                content: text,
+                timestamp,
+                tokenCount: tokenCount || undefined,
+            };
+        }
+        const nestedTool = obj.tool;
+        const nestedToolName = nestedTool &&
+            typeof nestedTool === "object" &&
+            typeof nestedTool.name === "string"
+            ? nestedTool.name
+            : undefined;
+        const toolName = (typeof obj.toolName === "string" ? obj.toolName : undefined) ||
+            nestedToolName;
+        if (toolName) {
+            parsed.toolMessages.push({
+                role: "tool",
+                content: JSON.stringify(obj.input ?? obj.toolInput ?? {}),
+                toolName,
+                timestamp,
+            });
+            const toolFileChange = this.fileChangeFromPayload(toolName, obj);
+            if (toolFileChange) {
+                parsed.fileChanges.push(toolFileChange);
+            }
+        }
+        if (Array.isArray(obj.toolCalls)) {
+            for (const toolCall of obj.toolCalls) {
+                if (!toolCall || typeof toolCall !== "object") {
+                    continue;
+                }
+                const call = toolCall;
+                const callName = call.name;
+                if (!callName) {
+                    continue;
+                }
+                parsed.toolMessages.push({
+                    role: "tool",
+                    content: JSON.stringify(call.input ?? {}),
+                    toolName: callName,
+                    timestamp,
+                });
+                const callPayload = call.input && typeof call.input === "object"
+                    ? call.input
+                    : call;
+                const callChange = this.fileChangeFromPayload(callName, callPayload);
+                if (callChange) {
+                    parsed.fileChanges.push(callChange);
+                }
+            }
+        }
+        const directChange = this.fileChangeFromPayload("edit_file", obj);
+        if (directChange) {
+            parsed.fileChanges.push(directChange);
+        }
+        return parsed;
+    }
+    fileChangeFromPayload(toolNameRaw, payload) {
+        const filePath = payload.path ||
+            payload.filePath ||
+            payload.file_path;
+        if (!filePath) {
+            return null;
+        }
+        const toolName = toolNameRaw.toLowerCase();
+        const changeType = toolName.includes("write") || toolName.includes("create")
+            ? "created"
+            : toolName.includes("delete")
+                ? "deleted"
+                : "modified";
+        const diff = payload.content ||
+            payload.diff ||
+            payload.new_content;
+        const ext = path.extname(filePath).slice(1);
+        return {
+            path: filePath,
+            changeType,
+            diff,
+            language: ext || undefined,
+        };
+    }
+    extractText(payload) {
+        const directContent = payload.content;
+        if (typeof directContent === "string") {
+            return directContent.trim();
+        }
+        if (typeof payload.text === "string") {
+            return payload.text.trim();
+        }
+        if (Array.isArray(directContent)) {
+            const textParts = [];
+            for (const item of directContent) {
+                if (typeof item === "string") {
+                    textParts.push(item);
+                    continue;
+                }
+                if (!item || typeof item !== "object") {
+                    continue;
+                }
+                const block = item;
+                if (typeof block.text === "string") {
+                    textParts.push(block.text);
+                }
+            }
+            return textParts.join("\n").trim();
+        }
+        const nestedMessage = payload.message;
+        if (nestedMessage && typeof nestedMessage === "object") {
+            const nested = nestedMessage;
+            if (typeof nested.content === "string") {
+                return nested.content.trim();
+            }
+            if (Array.isArray(nested.content)) {
+                const parts = [];
+                for (const item of nested.content) {
+                    if (typeof item === "string") {
+                        parts.push(item);
+                        continue;
+                    }
+                    if (!item || typeof item !== "object") {
+                        continue;
+                    }
+                    const block = item;
+                    if (typeof block.text === "string") {
+                        parts.push(block.text);
+                    }
+                }
+                return parts.join("\n").trim();
+            }
+        }
+        return "";
+    }
+    mapRole(rawRole) {
+        const role = (rawRole || "").toLowerCase();
+        if (role === "user" || role === "assistant" || role === "system" || role === "tool") {
+            return role;
+        }
+        if (role === "developer") {
+            return "system";
+        }
+        if (role === "human") {
+            return "user";
+        }
+        if (role === "ai") {
+            return "assistant";
+        }
+        return "assistant";
+    }
+    normalizeTimestamp(value) {
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number") {
+            return new Date(value).toISOString();
+        }
+        return undefined;
+    }
+    normalizeNumber(value) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return undefined;
+    }
+    readWorkspaceProjectPath(workspaceDir) {
+        const workspaceJsonPath = path.join(workspaceDir, "workspace.json");
+        if (!fs.existsSync(workspaceJsonPath)) {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(workspaceJsonPath, "utf-8"));
+            if (!parsed.folder) {
+                return undefined;
+            }
+            return this.fromFileUri(parsed.folder);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    fromFileUri(folder) {
+        if (!folder.startsWith("file://")) {
+            return folder;
+        }
+        try {
+            const url = new URL(folder);
+            let pathname = decodeURIComponent(url.pathname);
+            if (process.platform === "win32" && pathname.startsWith("/")) {
+                pathname = pathname.slice(1);
+            }
+            if (process.platform === "win32") {
+                pathname = pathname.replace(/\//g, "\\");
+            }
+            return pathname;
+        }
+        catch {
+            return folder.replace(/^file:\/\//, "");
+        }
+    }
+    pathsEqual(a, b) {
+        const normalize = (value) => path.resolve(value).replace(/[\\/]+/g, "/").toLowerCase();
+        return normalize(a) === normalize(b);
+    }
+    matchesWorkspaceHash(projectPath, workspaceHash) {
+        const normalizedPath = path.resolve(projectPath).replace(/\\/g, "/");
+        const uriPath = normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`;
+        const fileUri = `file://${uriPath}`;
+        const rawCandidates = [projectPath, normalizedPath, fileUri, encodeURI(fileUri)];
+        const hashCandidates = new Set();
+        for (const value of rawCandidates) {
+            hashCandidates.add(createHash("md5").update(value).digest("hex"));
+            hashCandidates.add(createHash("sha1").update(value).digest("hex"));
+            hashCandidates.add(createHash("sha256").update(value).digest("hex"));
+        }
+        return hashCandidates.has(workspaceHash.toLowerCase());
+    }
+}
+//# sourceMappingURL=adapter.js.map