codeblog-mcp 0.8.0

package/dist/scanners/continue-dev.js

@@ -0,0 +1,136 @@
+import * as path from "path";
+import * as fs from "fs";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listFiles, safeReadJson, safeStats } from "../lib/fs-utils.js";
+// Continue.dev stores sessions in:
+// ~/.continue/sessions/*.json
+// macOS:   ~/Library/Application Support/Continue/sessions/
+// Windows: %APPDATA%/Continue/sessions/
+// Linux:   ~/.config/continue/sessions/
+export const continueDevScanner = {
+    name: "Continue.dev",
+    sourceType: "continue",
+    description: "Continue.dev AI coding assistant sessions",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        candidates.push(path.join(home, ".continue", "sessions"));
+        if (platform === "macos") {
+            candidates.push(path.join(home, "Library", "Application Support", "Continue", "sessions"));
+        }
+        else if (platform === "windows") {
+            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+            candidates.push(path.join(appData, "Continue", "sessions"));
+        }
+        else {
+            candidates.push(path.join(home, ".config", "continue", "sessions"));
+        }
+        return candidates.filter((d) => {
+            try {
+                return fs.existsSync(d);
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    scan(limit) {
+        const sessions = [];
+        const dirs = this.getSessionDirs();
+        for (const dir of dirs) {
+            const jsonFiles = listFiles(dir, [".json"]);
+            for (const filePath of jsonFiles) {
+                const stats = safeStats(filePath);
+                if (!stats || stats.size < 100)
+                    continue;
+                const data = safeReadJson(filePath);
+                if (!data)
+                    continue;
+                const turns = extractContinueTurns(data);
+                if (turns.length < 2)
+                    continue;
+                const humanMsgs = turns.filter((t) => t.role === "human");
+                const preview = humanMsgs[0]?.content.slice(0, 200) || "(continue session)";
+                sessions.push({
+                    id: path.basename(filePath, ".json"),
+                    source: "continue",
+                    project: data.workspacePath || path.basename(path.dirname(filePath)),
+                    title: data.title || preview.slice(0, 80),
+                    messageCount: turns.length,
+                    humanMessages: humanMsgs.length,
+                    aiMessages: turns.length - humanMsgs.length,
+                    preview,
+                    filePath,
+                    modifiedAt: stats.mtime,
+                    sizeBytes: stats.size,
+                });
+            }
+        }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        const data = safeReadJson(filePath);
+        if (!data)
+            return null;
+        const stats = safeStats(filePath);
+        const turns = extractContinueTurns(data, maxTurns);
+        if (turns.length === 0)
+            return null;
+        const humanMsgs = turns.filter((t) => t.role === "human");
+        const aiMsgs = turns.filter((t) => t.role === "assistant");
+        return {
+            id: path.basename(filePath, ".json"),
+            source: "continue",
+            project: data.workspacePath || path.basename(path.dirname(filePath)),
+            title: data.title || humanMsgs[0]?.content.slice(0, 80) || "Continue session",
+            messageCount: turns.length,
+            humanMessages: humanMsgs.length,
+            aiMessages: aiMsgs.length,
+            preview: humanMsgs[0]?.content.slice(0, 200) || "",
+            filePath,
+            modifiedAt: stats?.mtime || new Date(),
+            sizeBytes: stats?.size || 0,
+            turns,
+        };
+    },
+};
+function extractContinueTurns(data, maxTurns) {
+    const turns = [];
+    // Continue format: { history: [{ role: "user"|"assistant", content: "..." }] }
+    const msgArrays = [data.history, data.messages, data.steps];
+    for (const arr of msgArrays) {
+        if (!Array.isArray(arr))
+            continue;
+        for (const msg of arr) {
+            if (maxTurns && turns.length >= maxTurns)
+                break;
+            if (!msg || typeof msg !== "object")
+                continue;
+            const m = msg;
+            // Steps format: { name: "UserInput", description: "..." }
+            if (m.name === "UserInput" && typeof m.description === "string") {
+                turns.push({ role: "human", content: m.description });
+                continue;
+            }
+            if (m.name === "DefaultModelEditCodeStep" || m.name === "ChatModelResponse") {
+                if (typeof m.description === "string") {
+                    turns.push({ role: "assistant", content: m.description });
+                }
+                continue;
+            }
+            // Standard message format
+            const content = (m.content || m.text || m.message);
+            if (typeof content !== "string")
+                continue;
+            turns.push({
+                role: m.role === "user" ? "human" : "assistant",
+                content,
+            });
+        }
+        if (turns.length > 0)
+            return turns;
+    }
+    return turns;
+}

package/dist/scanners/cursor.d.ts

@@ -0,0 +1,2 @@
+import type { Scanner } from "../lib/types.js";
+export declare const cursorScanner: Scanner;

package/dist/scanners/cursor.js

@@ -0,0 +1,447 @@
+import * as path from "path";
+import * as fs from "fs";
+import BetterSqlite3 from "better-sqlite3";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listFiles, listDirs, safeReadFile, safeReadJson, safeStats, extractProjectDescription } from "../lib/fs-utils.js";
+// Cursor stores conversations in THREE places (all supported for version compatibility):
+//
+// FORMAT 1 — Agent transcripts (plain text, XML-like tags):
+//   ~/.cursor/projects/<project>/agent-transcripts/*.txt
+//   Format: user: <user_query>...</user_query> \n A: <response>
+//
+// FORMAT 2 — Chat sessions (JSON, older Cursor versions):
+//   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
+//   Format: { requests: [{ message: "...", response: [...] }], sessionId, creationDate }
+//
+// FORMAT 3 — Global SQLite (newer Cursor versions, 2025+):
+//   ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+//   Table: cursorDiskKV
+//   Keys:  composerData:<composerId> — session metadata (name, timestamps, bubble headers)
+//          bubbleId:<composerId>:<bubbleId> — individual message content (type 1=user, 2=ai)
+// Run a callback with a shared DB connection, safely closing on completion
+function withDb(dbPath, fn, fallback) {
+    try {
+        const db = new BetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            return fn(db);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        console.error(`[codeblog] Cursor DB error:`, err instanceof Error ? err.message : err);
+        return fallback;
+    }
+}
+// Safe parameterized query helper
+function safeQueryDb(db, sql, params = []) {
+    try {
+        return db.prepare(sql).all(...params);
+    }
+    catch (err) {
+        console.error(`[codeblog] Cursor query error:`, err instanceof Error ? err.message : err);
+        return [];
+    }
+}
+// Parse vscdb virtual path: "vscdb:<dbPath>|<composerId>"
+// Uses '|' as separator to avoid conflicts with ':' in Windows paths (C:\...)
+const VSCDB_SEP = "|";
+function makeVscdbPath(dbPath, composerId) {
+    return `vscdb:${dbPath}${VSCDB_SEP}${composerId}`;
+}
+function parseVscdbVirtualPath(virtualPath) {
+    const prefix = "vscdb:";
+    if (!virtualPath.startsWith(prefix))
+        return null;
+    const rest = virtualPath.slice(prefix.length);
+    const sepIdx = rest.lastIndexOf(VSCDB_SEP);
+    if (sepIdx <= 0)
+        return null;
+    return { dbPath: rest.slice(0, sepIdx), composerId: rest.slice(sepIdx + 1) };
+}
+function getGlobalStoragePath() {
+    const home = getHome();
+    const platform = getPlatform();
+    let p;
+    if (platform === "macos") {
+        p = path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    else if (platform === "windows") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        p = path.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    else {
+        p = path.join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    try {
+        return fs.existsSync(p) ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const cursorScanner = {
+    name: "Cursor",
+    sourceType: "cursor",
+    description: "Cursor AI IDE sessions (agent transcripts + chat sessions + composer)",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        // Format 1: Agent transcripts
+        candidates.push(path.join(home, ".cursor", "projects"));
+        // Format 2 & workspace-level Format 3: workspaceStorage
+        if (platform === "macos") {
+            candidates.push(path.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"));
+        }
+        else if (platform === "windows") {
+            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+            candidates.push(path.join(appData, "Cursor", "User", "workspaceStorage"));
+        }
+        else {
+            candidates.push(path.join(home, ".config", "Cursor", "User", "workspaceStorage"));
+        }
+        // Format 3: globalStorage (just check existence for status reporting)
+        const globalDb = getGlobalStoragePath();
+        if (globalDb) {
+            candidates.push(path.dirname(globalDb));
+        }
+        return candidates.filter((d) => {
+            try {
+                return fs.existsSync(d);
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    scan(limit) {
+        const sessions = [];
+        const dirs = this.getSessionDirs();
+        const seenIds = new Set();
+        for (const baseDir of dirs) {
+            // Skip globalStorage dir — handled separately via Format 3
+            if (baseDir.endsWith("globalStorage"))
+                continue;
+            const projectDirs = listDirs(baseDir);
+            for (const projectDir of projectDirs) {
+                const dirName = path.basename(projectDir);
+                let projectPath;
+                const workspaceJson = safeReadJson(path.join(projectDir, "workspace.json"));
+                if (workspaceJson?.folder) {
+                    try {
+                        projectPath = decodeURIComponent(new URL(workspaceJson.folder).pathname);
+                    }
+                    catch { /* */ }
+                }
+                if (!projectPath && dirName.startsWith("Users-")) {
+                    projectPath = decodeDirNameToPath(dirName) || undefined;
+                }
+                const project = projectPath ? path.basename(projectPath) : dirName;
+                const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined;
+                // --- FORMAT 1: agent-transcripts/*.txt ---
+                const transcriptsDir = path.join(projectDir, "agent-transcripts");
+                for (const filePath of listFiles(transcriptsDir, [".txt"])) {
+                    const stats = safeStats(filePath);
+                    if (!stats)
+                        continue;
+                    const content = safeReadFile(filePath);
+                    if (!content || content.length < 100)
+                        continue;
+                    const userQueries = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/g) || [];
+                    if (userQueries.length === 0)
+                        continue;
+                    const firstQuery = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/);
+                    const preview = firstQuery ? firstQuery[1].trim().slice(0, 200) : content.slice(0, 200);
+                    const id = path.basename(filePath, ".txt");
+                    seenIds.add(id);
+                    sessions.push({
+                        id,
+                        source: "cursor",
+                        project,
+                        projectPath,
+                        projectDescription,
+                        title: preview.slice(0, 80) || `Cursor session in ${project}`,
+                        messageCount: userQueries.length * 2,
+                        humanMessages: userQueries.length,
+                        aiMessages: userQueries.length,
+                        preview,
+                        filePath,
+                        modifiedAt: stats.mtime,
+                        sizeBytes: stats.size,
+                    });
+                }
+                // --- FORMAT 2: chatSessions/*.json ---
+                for (const filePath of listFiles(path.join(projectDir, "chatSessions"), [".json"])) {
+                    const stats = safeStats(filePath);
+                    if (!stats || stats.size < 100)
+                        continue;
+                    const data = safeReadJson(filePath);
+                    if (!data || !Array.isArray(data.requests) || data.requests.length === 0)
+                        continue;
+                    const humanCount = data.requests.length;
+                    const firstMsg = data.requests[0]?.message || "";
+                    const preview = (typeof firstMsg === "string" ? firstMsg : "").slice(0, 200);
+                    const id = data.sessionId || path.basename(filePath, ".json");
+                    seenIds.add(id);
+                    sessions.push({
+                        id,
+                        source: "cursor",
+                        project,
+                        projectPath,
+                        projectDescription,
+                        title: preview.slice(0, 80) || `Cursor chat in ${project}`,
+                        messageCount: humanCount * 2,
+                        humanMessages: humanCount,
+                        aiMessages: humanCount,
+                        preview: preview || "(cursor chat session)",
+                        filePath,
+                        modifiedAt: stats.mtime,
+                        sizeBytes: stats.size,
+                    });
+                }
+            }
+        }
+        // --- FORMAT 3: globalStorage state.vscdb (newer Cursor) ---
+        // This supplements Formats 1 & 2 — adds any sessions not already found
+        const globalDb = getGlobalStoragePath();
+        if (globalDb) {
+            withDb(globalDb, (db) => {
+                const rows = safeQueryDb(db, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'");
+                for (const row of rows) {
+                    try {
+                        const data = JSON.parse(row.value);
+                        const composerId = data.composerId || row.key.replace("composerData:", "");
+                        if (seenIds.has(composerId))
+                            continue;
+                        const bubbleHeaders = data.fullConversationHeadersOnly || [];
+                        if (bubbleHeaders.length === 0)
+                            continue;
+                        const humanCount = bubbleHeaders.filter((b) => b.type === 1).length;
+                        const aiCount = bubbleHeaders.filter((b) => b.type === 2).length;
+                        const name = data.name || "";
+                        // Get first user message as preview
+                        let preview = name;
+                        if (!preview) {
+                            const firstUserBubble = bubbleHeaders.find((b) => b.type === 1);
+                            if (firstUserBubble) {
+                                const bubbleRow = safeQueryDb(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [`bubbleId:${composerId}:${firstUserBubble.bubbleId}`]);
+                                if (bubbleRow.length > 0) {
+                                    try {
+                                        const bubble = JSON.parse(bubbleRow[0].value);
+                                        preview = (bubble.text || bubble.message || "").slice(0, 200);
+                                    }
+                                    catch { /* */ }
+                                }
+                            }
+                        }
+                        const createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
+                        const updatedAt = data.lastUpdatedAt ? new Date(data.lastUpdatedAt) : createdAt;
+                        sessions.push({
+                            id: composerId,
+                            source: "cursor",
+                            project: "Cursor Composer",
+                            title: (name || preview || "Cursor composer session").slice(0, 80),
+                            messageCount: humanCount + aiCount,
+                            humanMessages: humanCount,
+                            aiMessages: aiCount,
+                            preview: preview || "(composer session)",
+                            filePath: makeVscdbPath(globalDb, composerId),
+                            modifiedAt: updatedAt,
+                            sizeBytes: row.value.length,
+                        });
+                    }
+                    catch { /* skip malformed entries */ }
+                }
+            }, undefined);
+        }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        // FORMAT 3: vscdb virtual path
+        if (filePath.startsWith("vscdb:")) {
+            return parseVscdbSession(filePath, maxTurns);
+        }
+        const stats = safeStats(filePath);
+        const turns = [];
+        if (filePath.endsWith(".txt")) {
+            // FORMAT 1: agent transcript
+            const content = safeReadFile(filePath);
+            if (!content)
+                return null;
+            const blocks = content.split(/^user:\s*$/m);
+            for (const block of blocks) {
+                if (!block.trim())
+                    continue;
+                if (maxTurns && turns.length >= maxTurns)
+                    break;
+                const queryMatch = block.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/);
+                if (queryMatch) {
+                    turns.push({ role: "human", content: queryMatch[1].trim() });
+                }
+                const afterQuery = block.split(/<\/user_query>/)[1];
+                if (afterQuery) {
+                    const aiContent = afterQuery.replace(/^\s*\n\s*A:\s*\n?/, "").trim();
+                    if (aiContent && (!maxTurns || turns.length < maxTurns)) {
+                        turns.push({ role: "assistant", content: aiContent });
+                    }
+                }
+            }
+        }
+        else {
+            // FORMAT 2: chatSessions JSON
+            const data = safeReadJson(filePath);
+            if (!data || !Array.isArray(data.requests))
+                return null;
+            for (const req of data.requests) {
+                if (maxTurns && turns.length >= maxTurns)
+                    break;
+                if (req.message) {
+                    turns.push({
+                        role: "human",
+                        content: typeof req.message === "string" ? req.message : JSON.stringify(req.message),
+                    });
+                }
+                if (maxTurns && turns.length >= maxTurns)
+                    break;
+                if (req.response) {
+                    let respText = "";
+                    if (typeof req.response === "string") {
+                        respText = req.response;
+                    }
+                    else if (Array.isArray(req.response)) {
+                        respText = req.response
+                            .map((r) => (typeof r === "string" ? r : r?.text || ""))
+                            .join("");
+                    }
+                    if (respText.trim()) {
+                        turns.push({ role: "assistant", content: respText.trim() });
+                    }
+                }
+            }
+        }
+        if (turns.length === 0)
+            return null;
+        const humanMsgs = turns.filter((t) => t.role === "human");
+        const aiMsgs = turns.filter((t) => t.role === "assistant");
+        return {
+            id: path.basename(filePath).replace(/\.\w+$/, ""),
+            source: "cursor",
+            project: path.basename(path.dirname(filePath)),
+            title: humanMsgs[0]?.content.slice(0, 80) || "Cursor session",
+            messageCount: turns.length,
+            humanMessages: humanMsgs.length,
+            aiMessages: aiMsgs.length,
+            preview: humanMsgs[0]?.content.slice(0, 200) || "",
+            filePath,
+            modifiedAt: stats?.mtime || new Date(),
+            sizeBytes: stats?.size || 0,
+            turns,
+        };
+    },
+};
+// Parse a session stored in globalStorage state.vscdb (Format 3)
+function parseVscdbSession(virtualPath, maxTurns) {
+    const parsed = parseVscdbVirtualPath(virtualPath);
+    if (!parsed)
+        return null;
+    const { dbPath, composerId } = parsed;
+    return withDb(dbPath, (db) => {
+        // Get composer metadata
+        const metaRows = safeQueryDb(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [`composerData:${composerId}`]);
+        if (metaRows.length === 0)
+            return null;
+        let composerData;
+        try {
+            composerData = JSON.parse(metaRows[0].value);
+        }
+        catch {
+            return null;
+        }
+        const bubbleHeaders = composerData.fullConversationHeadersOnly || [];
+        if (bubbleHeaders.length === 0)
+            return null;
+        // Fetch bubble contents — single DB connection reused for all queries
+        const turns = [];
+        for (const header of bubbleHeaders) {
+            if (maxTurns && turns.length >= maxTurns)
+                break;
+            const bubbleRows = safeQueryDb(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [`bubbleId:${composerId}:${header.bubbleId}`]);
+            if (bubbleRows.length === 0)
+                continue;
+            try {
+                const bubble = JSON.parse(bubbleRows[0].value);
+                const text = bubble.text || bubble.message || bubble.rawText || "";
+                if (!text && header.type === 2) {
+                    turns.push({ role: "assistant", content: "(AI response)" });
+                    continue;
+                }
+                turns.push({
+                    role: header.type === 1 ? "human" : "assistant",
+                    content: text || "(empty)",
+                });
+            }
+            catch { /* skip */ }
+        }
+        if (turns.length === 0)
+            return null;
+        const humanMsgs = turns.filter((t) => t.role === "human");
+        const aiMsgs = turns.filter((t) => t.role === "assistant");
+        return {
+            id: composerId,
+            source: "cursor",
+            project: "Cursor Composer",
+            title: composerData.name || humanMsgs[0]?.content.slice(0, 80) || "Cursor session",
+            messageCount: turns.length,
+            humanMessages: humanMsgs.length,
+            aiMessages: aiMsgs.length,
+            preview: humanMsgs[0]?.content.slice(0, 200) || "",
+            filePath: virtualPath,
+            modifiedAt: composerData.lastUpdatedAt ? new Date(composerData.lastUpdatedAt) : new Date(),
+            sizeBytes: 0,
+            turns,
+        };
+    }, null);
+}
+// Decode a directory name like "Users-zhaoyifei-my-cool-project" back to a real path.
+// On Windows, names look like "c-Users-PC-project" → "C:\Users\PC\project".
+// Greedy strategy: try longest segments first, check if path exists on disk.
+function decodeDirNameToPath(dirName) {
+    const platform = getPlatform();
+    const stripped = dirName.startsWith("-") ? dirName.slice(1) : dirName;
+    const parts = stripped.split("-");
+    let currentPath = "";
+    let i = 0;
+    // On Windows, the first part may be a drive letter (e.g. "c" → "C:")
+    if (platform === "windows" && parts.length > 0 && /^[a-zA-Z]$/.test(parts[0])) {
+        currentPath = parts[0].toUpperCase() + ":";
+        i = 1;
+    }
+    while (i < parts.length) {
+        let bestMatch = "";
+        let bestLen = 0;
+        for (let end = parts.length; end > i; end--) {
+            const segment = parts.slice(i, end).join("-");
+            const candidate = currentPath + path.sep + segment;
+            try {
+                if (fs.existsSync(candidate)) {
+                    bestMatch = candidate;
+                    bestLen = end - i;
+                    break;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (bestLen > 0) {
+            currentPath = bestMatch;
+            i += bestLen;
+        }
+        else {
+            currentPath += path.sep + parts[i];
+            i++;
+        }
+    }
+    return currentPath || null;
+}

package/dist/scanners/index.d.ts

@@ -0,0 +1 @@
+export declare function registerAllScanners(): void;

package/dist/scanners/index.js

@@ -0,0 +1,22 @@
+import { registerScanner } from "../lib/registry.js";
+import { claudeCodeScanner } from "./claude-code.js";
+import { cursorScanner } from "./cursor.js";
+import { windsurfScanner } from "./windsurf.js";
+import { codexScanner } from "./codex.js";
+import { warpScanner } from "./warp.js";
+import { vscodeCopilotScanner } from "./vscode-copilot.js";
+import { aiderScanner } from "./aider.js";
+import { continueDevScanner } from "./continue-dev.js";
+import { zedScanner } from "./zed.js";
+// Register all scanners
+export function registerAllScanners() {
+    registerScanner(claudeCodeScanner);
+    registerScanner(cursorScanner);
+    registerScanner(windsurfScanner);
+    registerScanner(codexScanner);
+    registerScanner(warpScanner);
+    registerScanner(vscodeCopilotScanner);
+    registerScanner(aiderScanner);
+    registerScanner(continueDevScanner);
+    registerScanner(zedScanner);
+}

package/dist/scanners/vscode-copilot.d.ts

@@ -0,0 +1,2 @@
+import type { Scanner } from "../lib/types.js";
+export declare const vscodeCopilotScanner: Scanner;