codeblog-mcp 0.8.0

package/dist/scanners/vscode-copilot.js

@@ -0,0 +1,179 @@
+import * as path from "path";
+import * as fs from "fs";
+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 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);
+                }
+            }
+        }
+        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 = 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 codeblog_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,197 @@
+import * as path from "path";
+import * as fs from "fs";
+import BetterSqlite3 from "better-sqlite3";
+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}|${sessionId}`, // encode session ID for parse()
+                        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) {
+        // filePath may contain an encoded session ID: "<dbPath>|<sessionId>"
+        const sepIdx = filePath.lastIndexOf("|");
+        const dbPath = sepIdx > 0 ? filePath.slice(0, sepIdx) : filePath;
+        const targetSessionId = sepIdx > 0 ? filePath.slice(sepIdx + 1) : null;
+        const chatData = readVscdbChatSessions(dbPath);
+        if (!chatData)
+            return null;
+        const stats = safeStats(dbPath);
+        const entries = Object.entries(chatData.entries);
+        if (entries.length === 0)
+            return null;
+        // Look up the specific session entry by ID, or fall back to first with messages
+        let targetEntry = null;
+        let targetId = path.basename(path.dirname(dbPath));
+        if (targetSessionId && chatData.entries[targetSessionId]) {
+            targetEntry = chatData.entries[targetSessionId];
+            targetId = targetSessionId;
+        }
+        else {
+            for (const [id, entry] of entries) {
+                const msgs = extractVscdbMessages(entry);
+                if (msgs.length >= 2) {
+                    targetEntry = entry;
+                    targetId = id;
+                    break;
+                }
+            }
+        }
+        if (!targetEntry)
+            return null;
+        const allTurns = extractVscdbMessages(targetEntry);
+        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: targetId,
+            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: dbPath,
+            modifiedAt: stats?.mtime || new Date(),
+            sizeBytes: stats?.size || 0,
+            turns,
+        };
+    },
+};
+function readVscdbChatSessions(dbPath) {
+    try {
+        const db = new BetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+        let row;
+        try {
+            row = db.prepare("SELECT value FROM ItemTable WHERE key = 'chat.ChatSessionStore.index'").get();
+        }
+        finally {
+            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;

package/dist/scanners/zed.js

@@ -0,0 +1,121 @@
+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";
+// Zed editor stores AI assistant conversations in:
+// macOS:   ~/Library/Application Support/Zed/conversations/
+//          ~/.config/zed/conversations/
+// Linux:   ~/.config/zed/conversations/
+// Windows: %APPDATA%/Zed/conversations/
+export const zedScanner = {
+    name: "Zed",
+    sourceType: "zed",
+    description: "Zed editor AI assistant conversations",
+    getSessionDirs() {
+        const home = getHome();
+        const platform = getPlatform();
+        const candidates = [];
+        if (platform === "macos") {
+            candidates.push(path.join(home, "Library", "Application Support", "Zed", "conversations"));
+        }
+        if (platform === "windows") {
+            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+            candidates.push(path.join(appData, "Zed", "conversations"));
+        }
+        candidates.push(path.join(home, ".config", "zed", "conversations"));
+        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", ".zed"], true);
+            for (const filePath of jsonFiles) {
+                const stats = safeStats(filePath);
+                if (!stats || stats.size < 100)
+                    continue;
+                const data = safeReadJson(filePath);
+                if (!data)
+                    continue;
+                const turns = extractZedTurns(data);
+                if (turns.length < 2)
+                    continue;
+                const humanMsgs = turns.filter((t) => t.role === "human");
+                const preview = humanMsgs[0]?.content.slice(0, 200) || "(zed session)";
+                sessions.push({
+                    id: path.basename(filePath).replace(/\.\w+$/, ""),
+                    source: "zed",
+                    project: data.project || 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 = extractZedTurns(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).replace(/\.\w+$/, ""),
+            source: "zed",
+            project: data.project || path.basename(path.dirname(filePath)),
+            title: data.title || humanMsgs[0]?.content.slice(0, 80) || "Zed 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 extractZedTurns(data, maxTurns) {
+    const turns = [];
+    // Zed format: { messages: [{ role: "user"|"assistant", content: "..." }] }
+    const msgArrays = [data.messages, data.conversation, 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.body || m.text);
+            if (typeof content !== "string")
+                continue;
+            turns.push({
+                role: m.role === "user" || m.role === "human" ? "human" : "assistant",
+                content,
+            });
+        }
+        if (turns.length > 0)
+            return turns;
+    }
+    return turns;
+}

package/dist/tools/forum.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerForumTools(server: McpServer): void;