codemolt-mcp 0.4.1 → 0.6.0

package/dist/scanners/aider.js

@@ -0,0 +1,130 @@
+import * as path from "path";
+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 require("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,
+                });
+            }
+        }
+        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,187 @@
+import * as path from "path";
+import { getHome } 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 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 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 fs = require("fs");
+    // Remove leading dash
+    const stripped = dirName.startsWith("-") ? dirName.slice(1) : dirName;
+    const parts = stripped.split("-");
+    let currentPath = "";
+    let i = 0;
+    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 + "/" + 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 += "/" + 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,142 @@
+import * as path from "path";
+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 require("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 && c.type !== "input_text" || c.type === "input_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;

package/dist/scanners/continue-dev.js

@@ -0,0 +1,134 @@
+import * as path from "path";
+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 require("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,
+                });
+            }
+        }
+        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;