codeblog-mcp 0.8.0

package/dist/lib/platform.js

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+export function getPlatform() {
+    switch (os.platform()) {
+        case "win32":
+            return "windows";
+        case "darwin":
+            return "macos";
+        default:
+            return "linux";
+    }
+}
+export function getHome() {
+    return os.homedir();
+}
+// Windows: %APPDATA%, %LOCALAPPDATA%, %USERPROFILE%
+// macOS: ~/Library/Application Support, ~/
+// Linux: ~/.config, ~/.local/share, ~/
+export function getAppDataDir() {
+    const platform = getPlatform();
+    if (platform === "windows") {
+        return process.env.APPDATA || path.join(getHome(), "AppData", "Roaming");
+    }
+    if (platform === "macos") {
+        return path.join(getHome(), "Library", "Application Support");
+    }
+    return process.env.XDG_CONFIG_HOME || path.join(getHome(), ".config");
+}
+export function getLocalAppDataDir() {
+    const platform = getPlatform();
+    if (platform === "windows") {
+        return process.env.LOCALAPPDATA || path.join(getHome(), "AppData", "Local");
+    }
+    if (platform === "macos") {
+        return path.join(getHome(), "Library", "Application Support");
+    }
+    return process.env.XDG_DATA_HOME || path.join(getHome(), ".local", "share");
+}
+// Resolve a list of candidate paths, return all that exist
+export function resolvePaths(candidates) {
+    return candidates.filter((p) => {
+        try {
+            return fs.existsSync(p);
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/lib/registry.d.ts

@@ -0,0 +1,14 @@
+import type { Scanner, Session, ParsedSession } from "./types.js";
+export declare function registerScanner(scanner: Scanner): void;
+export declare function getScanners(): Scanner[];
+export declare function getScannerBySource(source: string): Scanner | undefined;
+export declare function scanAll(limit?: number, source?: string): Session[];
+export declare function parseSession(filePath: string, source: string, maxTurns?: number): ParsedSession | null;
+export declare function listScannerStatus(): Array<{
+    name: string;
+    source: string;
+    description: string;
+    available: boolean;
+    dirs: string[];
+    error?: string;
+}>;

package/dist/lib/registry.js

@@ -0,0 +1,69 @@
+// Scanner registry — all IDE scanners register here
+// DESIGN: Every scanner is fully isolated. A single scanner crashing
+// (missing deps, changed file formats, permission errors, etc.)
+// MUST NEVER take down the whole MCP server.
+const scanners = [];
+export function registerScanner(scanner) {
+    scanners.push(scanner);
+}
+export function getScanners() {
+    return [...scanners];
+}
+export function getScannerBySource(source) {
+    return scanners.find((s) => s.sourceType === source);
+}
+// Safe wrapper: calls a scanner method, returns fallback on ANY error
+function safeScannerCall(scannerName, method, fn, fallback) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        console.error(`[codeblog] Scanner "${scannerName}" ${method} failed:`, err instanceof Error ? err.message : err);
+        return fallback;
+    }
+}
+// Scan all registered IDEs, merge and sort results
+// If source is provided, only scan that specific IDE
+export function scanAll(limit = 20, source) {
+    const allSessions = [];
+    const targets = source ? scanners.filter((s) => s.sourceType === source) : scanners;
+    for (const scanner of targets) {
+        const sessions = safeScannerCall(scanner.name, "scan", () => scanner.scan(limit), []);
+        allSessions.push(...sessions);
+    }
+    // Sort by modification time (newest first)
+    allSessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+    return allSessions.slice(0, limit);
+}
+// Parse a session file using the appropriate scanner
+export function parseSession(filePath, source, maxTurns) {
+    const scanner = getScannerBySource(source);
+    if (!scanner)
+        return null;
+    return safeScannerCall(scanner.name, "parse", () => scanner.parse(filePath, maxTurns), null);
+}
+// List available scanners with their status
+export function listScannerStatus() {
+    return scanners.map((s) => {
+        try {
+            const dirs = s.getSessionDirs();
+            return {
+                name: s.name,
+                source: s.sourceType,
+                description: s.description,
+                available: dirs.length > 0,
+                dirs,
+            };
+        }
+        catch (err) {
+            return {
+                name: s.name,
+                source: s.sourceType,
+                description: s.description,
+                available: false,
+                dirs: [],
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    });
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,47 @@
+export interface Session {
+    id: string;
+    source: SourceType;
+    project: string;
+    projectPath?: string;
+    projectDescription?: string;
+    title: string;
+    messageCount: number;
+    humanMessages: number;
+    aiMessages: number;
+    preview: string;
+    filePath: string;
+    modifiedAt: Date;
+    sizeBytes: number;
+}
+export interface ConversationTurn {
+    role: "human" | "assistant" | "system" | "tool";
+    content: string;
+    timestamp?: Date;
+}
+export interface ParsedSession extends Session {
+    turns: ConversationTurn[];
+}
+export interface SessionAnalysis {
+    summary: string;
+    topics: string[];
+    languages: string[];
+    keyInsights: string[];
+    codeSnippets: Array<{
+        language: string;
+        code: string;
+        context: string;
+    }>;
+    problems: string[];
+    solutions: string[];
+    suggestedTitle: string;
+    suggestedTags: string[];
+}
+export type SourceType = "claude-code" | "cursor" | "windsurf" | "codex" | "warp" | "vscode-copilot" | "aider" | "continue" | "zed" | "unknown";
+export interface Scanner {
+    name: string;
+    sourceType: SourceType;
+    description: string;
+    getSessionDirs(): string[];
+    scan(limit: number): Session[];
+    parse(filePath: string, maxTurns?: number): ParsedSession | null;
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scanners/aider.d.ts

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

package/dist/scanners/aider.js

@@ -0,0 +1,132 @@
+import * as path from "path";
+import * as fs from "fs";
+import { getHome } from "../lib/platform.js";
+import { listFiles, safeReadFile, safeStats } from "../lib/fs-utils.js";
+// Aider stores chat history in:
+// <project>/.aider.chat.history.md  (markdown format)
+// <project>/.aider.input.history    (readline history)
+// ~/.aider/history/                 (global history)
+// Same paths on all platforms
+export const aiderScanner = {
+    name: "Aider",
+    sourceType: "aider",
+    description: "Aider AI pair programming sessions",
+    getSessionDirs() {
+        const home = getHome();
+        const candidates = [
+            path.join(home, ".aider", "history"),
+            path.join(home, ".aider"),
+        ];
+        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 mdFiles = listFiles(dir, [".md"], true);
+            for (const filePath of mdFiles) {
+                if (!path.basename(filePath).includes("aider"))
+                    continue;
+                const stats = safeStats(filePath);
+                if (!stats || stats.size < 100)
+                    continue;
+                const content = safeReadFile(filePath);
+                if (!content)
+                    continue;
+                const { humanCount, aiCount, preview } = parseAiderMarkdown(content);
+                if (humanCount === 0)
+                    continue;
+                sessions.push({
+                    id: path.basename(filePath, ".md"),
+                    source: "aider",
+                    project: path.basename(path.dirname(filePath)),
+                    title: preview.slice(0, 80) || "Aider session",
+                    messageCount: humanCount + aiCount,
+                    humanMessages: humanCount,
+                    aiMessages: aiCount,
+                    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 content = safeReadFile(filePath);
+        if (!content)
+            return null;
+        const stats = safeStats(filePath);
+        const turns = parseAiderTurns(content, 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, ".md"),
+            source: "aider",
+            project: path.basename(path.dirname(filePath)),
+            title: humanMsgs[0]?.content.slice(0, 80) || "Aider 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 parseAiderMarkdown(content) {
+    // Aider chat history format:
+    // #### <user message>
+    // <assistant response>
+    const userBlocks = content.split(/^####\s+/m).filter(Boolean);
+    let humanCount = 0;
+    let aiCount = 0;
+    let preview = "";
+    for (const block of userBlocks) {
+        const lines = block.split("\n");
+        const firstLine = lines[0]?.trim();
+        if (firstLine) {
+            humanCount++;
+            if (!preview)
+                preview = firstLine.slice(0, 200);
+            // Everything after the first line is AI response
+            const rest = lines.slice(1).join("\n").trim();
+            if (rest)
+                aiCount++;
+        }
+    }
+    return { humanCount, aiCount, preview };
+}
+function parseAiderTurns(content, maxTurns) {
+    const turns = [];
+    const blocks = content.split(/^####\s+/m).filter(Boolean);
+    for (const block of blocks) {
+        if (maxTurns && turns.length >= maxTurns)
+            break;
+        const lines = block.split("\n");
+        const userMsg = lines[0]?.trim();
+        if (userMsg) {
+            turns.push({ role: "human", content: userMsg });
+            const aiResponse = lines.slice(1).join("\n").trim();
+            if (aiResponse) {
+                if (maxTurns && turns.length >= maxTurns)
+                    break;
+                turns.push({ role: "assistant", content: aiResponse });
+            }
+        }
+    }
+    return turns;
+}

package/dist/scanners/claude-code.d.ts

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

package/dist/scanners/claude-code.js

@@ -0,0 +1,193 @@
+import * as path from "path";
+import * as fs from "fs";
+import { getHome, getPlatform } from "../lib/platform.js";
+import { listFiles, listDirs, safeStats, readJsonl, extractProjectDescription } from "../lib/fs-utils.js";
+export const claudeCodeScanner = {
+    name: "Claude Code",
+    sourceType: "claude-code",
+    description: "Claude Code CLI sessions (~/.claude/projects/)",
+    getSessionDirs() {
+        const home = getHome();
+        const candidates = [path.join(home, ".claude", "projects")];
+        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 projectDirs = listDirs(baseDir);
+            for (const projectDir of projectDirs) {
+                const project = path.basename(projectDir);
+                const files = listFiles(projectDir, [".jsonl"]);
+                for (const filePath of files) {
+                    const stats = safeStats(filePath);
+                    if (!stats)
+                        continue;
+                    const lines = readJsonl(filePath);
+                    if (lines.length < 3)
+                        continue;
+                    const humanMsgs = lines.filter((l) => l.type === "user");
+                    const aiMsgs = lines.filter((l) => l.type === "assistant");
+                    // Extract cwd (project path) from first message that has it
+                    const cwdLine = lines.find((l) => l.cwd);
+                    let projectPath = cwdLine?.cwd || null;
+                    // Fallback: derive from directory name (e.g. "-Users-zhaoyifei-Foo" → "/Users/zhaoyifei/Foo")
+                    if (!projectPath && project.startsWith("-")) {
+                        projectPath = decodeClaudeProjectDir(project);
+                    }
+                    const projectName = projectPath ? path.basename(projectPath) : project;
+                    // Get project description from README/package.json
+                    const projectDescription = projectPath
+                        ? extractProjectDescription(projectPath)
+                        : null;
+                    let preview = "";
+                    for (const msg of humanMsgs.slice(0, 8)) {
+                        const content = extractContent(msg);
+                        if (!content || content.length < 10)
+                            continue;
+                        // Skip system-like messages and slash commands
+                        if (content.startsWith("<local-command-caveat>"))
+                            continue;
+                        if (content.startsWith("<environment_context>"))
+                            continue;
+                        if (content.startsWith("<command-name>"))
+                            continue;
+                        preview = content.slice(0, 200);
+                        break;
+                    }
+                    sessions.push({
+                        id: path.basename(filePath, ".jsonl"),
+                        source: "claude-code",
+                        project: projectName,
+                        projectPath: projectPath || undefined,
+                        projectDescription: projectDescription || undefined,
+                        title: preview.slice(0, 80) || `Claude session in ${projectName}`,
+                        messageCount: humanMsgs.length + aiMsgs.length,
+                        humanMessages: humanMsgs.length,
+                        aiMessages: aiMsgs.length,
+                        preview: preview || "(no preview)",
+                        filePath,
+                        modifiedAt: stats.mtime,
+                        sizeBytes: stats.size,
+                    });
+                }
+            }
+        }
+        // Sort by modification time (newest first), then apply limit
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+        return sessions.slice(0, limit);
+    },
+    parse(filePath, maxTurns) {
+        const lines = readJsonl(filePath);
+        if (lines.length === 0)
+            return null;
+        const stats = safeStats(filePath);
+        const turns = [];
+        // Extract project info
+        const cwdLine = lines.find((l) => l.cwd);
+        const projectPath = cwdLine?.cwd || undefined;
+        const projectName = projectPath
+            ? path.basename(projectPath)
+            : path.basename(path.dirname(filePath));
+        const projectDescription = projectPath
+            ? extractProjectDescription(projectPath) || undefined
+            : undefined;
+        for (const line of lines) {
+            if (maxTurns && turns.length >= maxTurns)
+                break;
+            if (line.type !== "user" && line.type !== "assistant")
+                continue;
+            const content = extractContent(line);
+            if (!content)
+                continue;
+            const role = line.type === "user" ? "human" : "assistant";
+            turns.push({
+                role,
+                content,
+                timestamp: line.timestamp ? new Date(line.timestamp) : undefined,
+            });
+        }
+        const humanMsgs = turns.filter((t) => t.role === "human");
+        const aiMsgs = turns.filter((t) => t.role === "assistant");
+        return {
+            id: path.basename(filePath, ".jsonl"),
+            source: "claude-code",
+            project: projectName,
+            projectPath,
+            projectDescription,
+            title: humanMsgs[0]?.content.slice(0, 80) || "Claude 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,
+        };
+    },
+};
+// Decode Claude Code project directory name back to a real path.
+// e.g. "-Users-zhaoyifei-VibeCodingWork-ai-code-forum" → "/Users/zhaoyifei/VibeCodingWork/ai-code-forum"
+// The challenge: hyphens in the dir name could be path separators OR part of a folder name.
+// Strategy: greedily build path segments, checking which paths actually exist on disk.
+function decodeClaudeProjectDir(dirName) {
+    const platform = getPlatform();
+    // Remove leading dash
+    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) {
+        // Try progressively longer segments (greedy: longest existing path wins)
+        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; // Found longest match
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (bestLen > 0) {
+            currentPath = bestMatch;
+            i += bestLen;
+        }
+        else {
+            // No existing path found, just use single segment
+            currentPath += path.sep + parts[i];
+            i++;
+        }
+    }
+    return currentPath || null;
+}
+function extractContent(msg) {
+    if (!msg.message?.content)
+        return "";
+    if (typeof msg.message.content === "string")
+        return msg.message.content;
+    if (Array.isArray(msg.message.content)) {
+        return msg.message.content
+            .filter((c) => c.type === "text" && c.text)
+            .map((c) => c.text)
+            .join("\n");
+    }
+    return "";
+}

package/dist/scanners/codex.d.ts

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

package/dist/scanners/codex.js

@@ -0,0 +1,143 @@
+import * as path from "path";
+import * as fs from "fs";
+import { getHome } from "../lib/platform.js";
+import { listFiles, safeStats, readJsonl, extractProjectDescription } from "../lib/fs-utils.js";
+export const codexScanner = {
+    name: "Codex (OpenAI CLI)",
+    sourceType: "codex",
+    description: "OpenAI Codex CLI sessions (~/.codex/)",
+    getSessionDirs() {
+        const home = getHome();
+        const candidates = [
+            path.join(home, ".codex", "sessions"),
+            path.join(home, ".codex", "archived_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) {
+            // Recursive scan — sessions are in nested YYYY/MM/DD/ subdirectories
+            const files = listFiles(dir, [".jsonl"], true);
+            for (const filePath of files) {
+                const stats = safeStats(filePath);
+                if (!stats)
+                    continue;
+                const lines = readJsonl(filePath);
+                if (lines.length < 3)
+                    continue;
+                const messageTurns = extractCodexTurns(lines);
+                const humanMsgs = messageTurns.filter((t) => t.role === "human");
+                const aiMsgs = messageTurns.filter((t) => t.role === "assistant");
+                // Extract project path (cwd) from session metadata
+                const startLine = lines.find((l) => l.payload?.cwd);
+                const projectPath = startLine?.payload?.cwd || null;
+                const project = projectPath
+                    ? path.basename(projectPath)
+                    : path.basename(dir);
+                const projectDescription = projectPath
+                    ? extractProjectDescription(projectPath)
+                    : null;
+                const preview = humanMsgs[0]?.content.slice(0, 200) || "(codex session)";
+                sessions.push({
+                    id: path.basename(filePath, ".jsonl"),
+                    source: "codex",
+                    project,
+                    projectPath: projectPath || undefined,
+                    projectDescription: projectDescription || undefined,
+                    title: preview.slice(0, 80) || "Codex session",
+                    messageCount: messageTurns.length,
+                    humanMessages: humanMsgs.length,
+                    aiMessages: aiMsgs.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 lines = readJsonl(filePath);
+        if (lines.length === 0)
+            return null;
+        const stats = safeStats(filePath);
+        const allTurns = extractCodexTurns(lines);
+        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");
+        const startLine = lines.find((l) => l.payload?.cwd);
+        const projectPath = startLine?.payload?.cwd || undefined;
+        const project = projectPath
+            ? path.basename(projectPath)
+            : path.basename(path.dirname(filePath));
+        const projectDescription = projectPath
+            ? extractProjectDescription(projectPath) || undefined
+            : undefined;
+        return {
+            id: path.basename(filePath, ".jsonl"),
+            source: "codex",
+            project,
+            projectPath,
+            projectDescription,
+            title: humanMsgs[0]?.content.slice(0, 80) || "Codex 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,
+        };
+    },
+};
+// Extract conversation turns from Codex JSONL format
+function extractCodexTurns(lines) {
+    const turns = [];
+    for (const line of lines) {
+        if (!line.payload)
+            continue;
+        const p = line.payload;
+        // Only process message-type payloads
+        if (p.type !== "message")
+            continue;
+        // Extract text from content array
+        const textParts = (p.content || [])
+            .filter((c) => c.text)
+            .map((c) => c.text || "")
+            .filter(Boolean);
+        const content = textParts.join("\n").trim();
+        if (!content)
+            continue;
+        // Skip developer/system messages — they are AGENTS.md instructions, not conversation
+        if (p.role === "developer" || p.role === "system")
+            continue;
+        // Skip system-like user messages (AGENTS.md, environment context, etc.)
+        if (p.role === "user" && (content.startsWith("# AGENTS.md") ||
+            content.startsWith("<environment_context>") ||
+            content.startsWith("<permissions") ||
+            content.startsWith("<app-context>") ||
+            content.startsWith("<collaboration_mode>")))
+            continue;
+        const role = p.role === "user" ? "human" : "assistant";
+        turns.push({
+            role,
+            content,
+            timestamp: line.timestamp ? new Date(line.timestamp) : undefined,
+        });
+    }
+    return turns;
+}

package/dist/scanners/continue-dev.d.ts

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