codemolt-mcp 0.4.1 → 0.6.0

package/dist/scanners/cursor.js

@@ -0,0 +1,219 @@
+import * as path from "path";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listFiles, listDirs, safeReadFile, safeReadJson, safeStats, extractProjectDescription } from "../lib/fs-utils.js";
+// Cursor stores conversations in two places:
+//
+// 1. Agent transcripts (plain text, XML-like tags):
+//    ~/.cursor/projects/<project>/agent-transcripts/*.txt
+//    Format: user: <user_query>...</user_query> \n A: <response>
+//
+// 2. Chat sessions (JSON):
+//    macOS:   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
+//    Windows: %APPDATA%/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
+//    Linux:   ~/.config/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
+//    Format:  { requests: [{ message: "...", response: [...] }], sessionId, creationDate }
+export const cursorScanner = {
+    name: "Cursor",
+    sourceType: "cursor",
+    description: "Cursor AI IDE sessions (agent transcripts + chat sessions)",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        // Agent transcripts (all platforms)
+        candidates.push(path.join(home, ".cursor", "projects"));
+        // Chat sessions in 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"));
+        }
+        return candidates.filter((d) => {
+            try {
+                return require("fs").existsSync(d);
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    scan(limit) {
+        const sessions = [];
+        const dirs = this.getSessionDirs();
+        for (const baseDir of dirs) {
+            const projectDirs = listDirs(baseDir);
+            for (const projectDir of projectDirs) {
+                const dirName = path.basename(projectDir);
+                // Resolve project path:
+                // - agent-transcripts dirs: "Users-zhaoyifei-SimenDevelop-Simen" → "/Users/zhaoyifei/SimenDevelop/Simen"
+                // - workspaceStorage dirs: read workspace.json for folder URI
+                let projectPath;
+                const workspaceJsonPath = path.join(projectDir, "workspace.json");
+                const workspaceJson = safeReadJson(workspaceJsonPath);
+                if (workspaceJson?.folder) {
+                    try {
+                        projectPath = decodeURIComponent(new URL(workspaceJson.folder).pathname);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (!projectPath && dirName.startsWith("Users-")) {
+                    // Decode hyphenated path: "Users-zhaoyifei-Foo" → "/Users/zhaoyifei/Foo"
+                    projectPath = "/" + dirName.replace(/-/g, "/");
+                }
+                const project = projectPath ? path.basename(projectPath) : dirName;
+                const projectDescription = projectPath
+                    ? extractProjectDescription(projectPath) || undefined
+                    : undefined;
+                // --- Path 1: agent-transcripts/*.txt ---
+                const transcriptsDir = path.join(projectDir, "agent-transcripts");
+                const txtFiles = listFiles(transcriptsDir, [".txt"]);
+                for (const filePath of txtFiles) {
+                    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) || [];
+                    const humanCount = userQueries.length;
+                    if (humanCount === 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);
+                    sessions.push({
+                        id: path.basename(filePath, ".txt"),
+                        source: "cursor",
+                        project,
+                        projectPath,
+                        projectDescription,
+                        title: preview.slice(0, 80) || `Cursor session in ${project}`,
+                        messageCount: humanCount * 2,
+                        humanMessages: humanCount,
+                        aiMessages: humanCount,
+                        preview,
+                        filePath,
+                        modifiedAt: stats.mtime,
+                        sizeBytes: stats.size,
+                    });
+                }
+                // --- Path 2: chatSessions/*.json (inside workspaceStorage/<hash>/) ---
+                const chatSessionsDir = path.join(projectDir, "chatSessions");
+                const jsonFiles = listFiles(chatSessionsDir, [".json"]);
+                for (const filePath of jsonFiles) {
+                    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);
+                    sessions.push({
+                        id: data.sessionId || path.basename(filePath, ".json"),
+                        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,
+                    });
+                }
+            }
+        }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        const stats = safeStats(filePath);
+        const turns = [];
+        if (filePath.endsWith(".txt")) {
+            // Parse agent transcript format:
+            // user:\n<user_query>\n...\n</user_query>\n\nA:\n...
+            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() });
+                }
+                // Everything after </user_query> and after "A:" is the assistant response
+                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 {
+            // Parse chatSessions JSON: { requests: [{ message, response }] }
+            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;
+                // Response can be array of text chunks or a string
+                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,
+        };
+    },
+};

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;

package/dist/scanners/vscode-copilot.js

@@ -0,0 +1,177 @@
+import * as path from "path";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listFiles, listDirs, safeReadJson, safeStats } from "../lib/fs-utils.js";
+// VS Code Copilot Chat stores conversations in:
+// macOS:   ~/Library/Application Support/Code/User/workspaceStorage/<hash>/github.copilot-chat/
+// Windows: %APPDATA%/Code/User/workspaceStorage/<hash>/github.copilot-chat/
+// Linux:   ~/.config/Code/User/workspaceStorage/<hash>/github.copilot-chat/
+//
+// Also checks VS Code Insiders and VSCodium paths
+export const vscodeCopilotScanner = {
+    name: "VS Code Copilot Chat",
+    sourceType: "vscode-copilot",
+    description: "GitHub Copilot Chat sessions in VS Code",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        const codeVariants = ["Code", "Code - Insiders", "VSCodium"];
+        for (const variant of codeVariants) {
+            if (platform === "macos") {
+                candidates.push(path.join(home, "Library", "Application Support", variant, "User", "workspaceStorage"));
+                candidates.push(path.join(home, "Library", "Application Support", variant, "User", "globalStorage", "github.copilot-chat"));
+            }
+            else if (platform === "windows") {
+                const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+                candidates.push(path.join(appData, variant, "User", "workspaceStorage"));
+                candidates.push(path.join(appData, variant, "User", "globalStorage", "github.copilot-chat"));
+            }
+            else {
+                candidates.push(path.join(home, ".config", variant, "User", "workspaceStorage"));
+                candidates.push(path.join(home, ".config", variant, "User", "globalStorage", "github.copilot-chat"));
+            }
+        }
+        return candidates.filter((d) => {
+            try {
+                return require("fs").existsSync(d);
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    scan(limit) {
+        const sessions = [];
+        const dirs = this.getSessionDirs();
+        for (const baseDir of dirs) {
+            // Check globalStorage copilot-chat directory
+            if (baseDir.includes("globalStorage")) {
+                const jsonFiles = listFiles(baseDir, [".json"]);
+                for (const filePath of jsonFiles) {
+                    const session = tryParseConversationFile(filePath);
+                    if (session)
+                        sessions.push(session);
+                }
+                continue;
+            }
+            // Check workspaceStorage — each hash dir may have a copilot-chat subfolder
+            const hashDirs = listDirs(baseDir);
+            for (const hashDir of hashDirs) {
+                const copilotDir = path.join(hashDir, "github.copilot-chat");
+                const jsonFiles = listFiles(copilotDir, [".json"]);
+                for (const filePath of jsonFiles) {
+                    const session = tryParseConversationFile(filePath);
+                    if (session)
+                        sessions.push(session);
+                }
+            }
+        }
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        const data = safeReadJson(filePath);
+        if (!data)
+            return null;
+        const stats = safeStats(filePath);
+        const turns = extractCopilotTurns(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: "vscode-copilot",
+            project: path.basename(path.dirname(filePath)),
+            title: humanMsgs[0]?.content.slice(0, 80) || "Copilot Chat 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 tryParseConversationFile(filePath) {
+    const stats = safeStats(filePath);
+    if (!stats || stats.size < 100)
+        return null;
+    const data = safeReadJson(filePath);
+    if (!data)
+        return null;
+    const turns = extractCopilotTurns(data);
+    if (turns.length < 2)
+        return null;
+    const humanMsgs = turns.filter((t) => t.role === "human");
+    const preview = humanMsgs[0]?.content.slice(0, 200) || "(copilot session)";
+    return {
+        id: path.basename(filePath, ".json"),
+        source: "vscode-copilot",
+        project: path.basename(path.dirname(filePath)),
+        title: preview.slice(0, 80),
+        messageCount: turns.length,
+        humanMessages: humanMsgs.length,
+        aiMessages: turns.length - humanMsgs.length,
+        preview,
+        filePath,
+        modifiedAt: stats.mtime,
+        sizeBytes: stats.size,
+    };
+}
+function extractCopilotTurns(data, maxTurns) {
+    const turns = [];
+    // Copilot Chat format: { conversations: [{ turns: [{ request: ..., response: ... }] }] }
+    if (Array.isArray(data.conversations)) {
+        for (const conv of data.conversations) {
+            if (!conv || typeof conv !== "object")
+                continue;
+            const c = conv;
+            if (!Array.isArray(c.turns))
+                continue;
+            for (const turn of c.turns) {
+                if (maxTurns && turns.length >= maxTurns)
+                    break;
+                const t = turn;
+                if (t.request && typeof t.request === "string") {
+                    turns.push({ role: "human", content: t.request });
+                }
+                if (t.response && typeof t.response === "string") {
+                    turns.push({ role: "assistant", content: t.response });
+                }
+                // Alternative format
+                if (t.message && typeof t.message === "string") {
+                    turns.push({
+                        role: t.role === "user" ? "human" : "assistant",
+                        content: t.message,
+                    });
+                }
+            }
+        }
+        return turns;
+    }
+    // Flat messages format
+    const msgArrays = [data.messages, data.history, data.entries];
+    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;
+            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/warp.d.ts

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

package/dist/scanners/warp.js

@@ -0,0 +1,20 @@
+// Warp Terminal AI chat is cloud-based and does NOT store conversation
+// history locally. Verified on macOS — ~/Library/Application Support/dev.warp.Warp-Stable/
+// contains only autoupdate data and logs, no AI chat files.
+//
+// This scanner is kept as a stub so codemolt_status can report it as unsupported.
+export const warpScanner = {
+    name: "Warp Terminal",
+    sourceType: "warp",
+    description: "Warp Terminal (AI chat is cloud-only, no local history)",
+    getSessionDirs() {
+        // Warp does not store AI chat locally
+        return [];
+    },
+    scan(_limit) {
+        return [];
+    },
+    parse(_filePath, _maxTurns) {
+        return null;
+    },
+};

package/dist/scanners/windsurf.d.ts

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

package/dist/scanners/windsurf.js

@@ -0,0 +1,171 @@
+import * as path from "path";
+import * as fs from "fs";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listDirs, safeReadJson, safeStats, extractProjectDescription } from "../lib/fs-utils.js";
+export const windsurfScanner = {
+    name: "Windsurf",
+    sourceType: "windsurf",
+    description: "Windsurf (Codeium) Cascade chat sessions (SQLite)",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        if (platform === "macos") {
+            candidates.push(path.join(home, "Library", "Application Support", "Windsurf", "User", "workspaceStorage"));
+        }
+        else if (platform === "windows") {
+            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+            candidates.push(path.join(appData, "Windsurf", "User", "workspaceStorage"));
+        }
+        else {
+            candidates.push(path.join(home, ".config", "Windsurf", "User", "workspaceStorage"));
+        }
+        return candidates.filter((d) => {
+            try {
+                return fs.existsSync(d);
+            }
+            catch {
+                return false;
+            }
+        });
+    },
+    scan(limit) {
+        const sessions = [];
+        const dirs = this.getSessionDirs();
+        for (const baseDir of dirs) {
+            const workspaceDirs = listDirs(baseDir);
+            for (const wsDir of workspaceDirs) {
+                const dbPath = path.join(wsDir, "state.vscdb");
+                if (!fs.existsSync(dbPath))
+                    continue;
+                // Read workspace.json to get project path
+                const wsJson = safeReadJson(path.join(wsDir, "workspace.json"));
+                let projectPath;
+                if (wsJson?.folder) {
+                    try {
+                        projectPath = decodeURIComponent(new URL(wsJson.folder).pathname);
+                    }
+                    catch { /* ignore */ }
+                }
+                const project = projectPath ? path.basename(projectPath) : path.basename(wsDir);
+                const projectDescription = projectPath
+                    ? extractProjectDescription(projectPath) || undefined
+                    : undefined;
+                // Read chat sessions from SQLite
+                const chatData = readVscdbChatSessions(dbPath);
+                if (!chatData || Object.keys(chatData.entries).length === 0)
+                    continue;
+                for (const [sessionId, entry] of Object.entries(chatData.entries)) {
+                    const messages = extractVscdbMessages(entry);
+                    if (messages.length < 2)
+                        continue;
+                    const humanMsgs = messages.filter((m) => m.role === "human");
+                    const preview = humanMsgs[0]?.content.slice(0, 200) || "(windsurf session)";
+                    const dbStats = safeStats(dbPath);
+                    sessions.push({
+                        id: sessionId,
+                        source: "windsurf",
+                        project,
+                        projectPath,
+                        projectDescription,
+                        title: preview.slice(0, 80),
+                        messageCount: messages.length,
+                        humanMessages: humanMsgs.length,
+                        aiMessages: messages.length - humanMsgs.length,
+                        preview,
+                        filePath: dbPath, // point to the vscdb file
+                        modifiedAt: dbStats?.mtime || new Date(),
+                        sizeBytes: dbStats?.size || 0,
+                    });
+                }
+            }
+        }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        const chatData = readVscdbChatSessions(filePath);
+        if (!chatData)
+            return null;
+        const stats = safeStats(filePath);
+        // Combine all entries' messages
+        const allTurns = [];
+        for (const entry of Object.values(chatData.entries)) {
+            const msgs = extractVscdbMessages(entry);
+            allTurns.push(...msgs);
+        }
+        const turns = maxTurns ? allTurns.slice(0, maxTurns) : allTurns;
+        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(path.dirname(filePath)),
+            source: "windsurf",
+            project: path.basename(path.dirname(filePath)),
+            title: humanMsgs[0]?.content.slice(0, 80) || "Windsurf 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 readVscdbChatSessions(dbPath) {
+    try {
+        const Database = require("better-sqlite3");
+        const db = new Database(dbPath, { readonly: true });
+        const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'chat.ChatSessionStore.index'").get();
+        db.close();
+        if (!row?.value)
+            return null;
+        const valueStr = typeof row.value === "string"
+            ? row.value
+            : row.value.toString("utf-8");
+        return JSON.parse(valueStr);
+    }
+    catch {
+        return null;
+    }
+}
+function extractVscdbMessages(entry) {
+    const turns = [];
+    if (Array.isArray(entry.messages)) {
+        for (const msg of entry.messages) {
+            if (!msg || typeof msg !== "object")
+                continue;
+            const content = msg.content || msg.text;
+            if (typeof content !== "string" || !content.trim())
+                continue;
+            turns.push({
+                role: msg.role === "user" || msg.role === "human" ? "human" : "assistant",
+                content,
+            });
+        }
+        return turns;
+    }
+    // Try other common keys
+    for (const [key, value] of Object.entries(entry)) {
+        if (!Array.isArray(value))
+            continue;
+        for (const item of value) {
+            if (!item || typeof item !== "object")
+                continue;
+            const m = item;
+            const content = (m.content || m.text);
+            if (typeof content !== "string" || !content.trim())
+                continue;
+            turns.push({
+                role: m.role === "user" || m.role === "human" ? "human" : "assistant",
+                content,
+            });
+        }
+        if (turns.length > 0)
+            return turns;
+    }
+    return turns;
+}

package/dist/scanners/zed.d.ts

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