codemolt-mcp 0.4.1 → 0.5.0

package/dist/lib/analyzer.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSession, SessionAnalysis } from "./types.js";
+export declare function analyzeSession(session: ParsedSession): SessionAnalysis;

package/dist/lib/analyzer.js

@@ -0,0 +1,225 @@
+// Analyze a parsed session and extract structured insights
+export function analyzeSession(session) {
+    const allContent = session.turns.map((t) => t.content).join("\n");
+    const humanContent = session.turns
+        .filter((t) => t.role === "human")
+        .map((t) => t.content)
+        .join("\n");
+    const aiContent = session.turns
+        .filter((t) => t.role === "assistant")
+        .map((t) => t.content)
+        .join("\n");
+    return {
+        summary: generateSummary(session),
+        topics: extractTopics(allContent),
+        languages: detectLanguages(allContent),
+        keyInsights: extractInsights(session.turns),
+        codeSnippets: extractCodeSnippets(allContent),
+        problems: extractProblems(humanContent),
+        solutions: extractSolutions(aiContent),
+        suggestedTitle: suggestTitle(session),
+        suggestedTags: suggestTags(allContent),
+    };
+}
+function generateSummary(session) {
+    const humanMsgs = session.turns.filter((t) => t.role === "human");
+    const topics = humanMsgs
+        .slice(0, 5)
+        .map((m) => m.content.slice(0, 100))
+        .join("; ");
+    return (`${session.source} session in project "${session.project}" with ` +
+        `${session.humanMessages} user messages and ${session.aiMessages} AI responses. ` +
+        `Topics discussed: ${topics}`);
+}
+function extractTopics(content) {
+    const topics = new Set();
+    // Common programming topics
+    const topicPatterns = [
+        [/\b(react|vue|angular|svelte|nextjs|next\.js|nuxt)\b/i, "frontend"],
+        [/\b(express|fastify|koa|nest\.?js|django|flask|rails)\b/i, "backend"],
+        [/\b(typescript|javascript|python|rust|go|java|c\+\+|ruby|swift|kotlin)\b/i, "programming-language"],
+        [/\b(docker|kubernetes|k8s|ci\/cd|deploy|devops)\b/i, "devops"],
+        [/\b(sql|postgres|mysql|mongodb|redis|database|prisma|drizzle)\b/i, "database"],
+        [/\b(test|jest|vitest|pytest|testing|spec|unit test)\b/i, "testing"],
+        [/\b(api|rest|graphql|grpc|websocket)\b/i, "api"],
+        [/\b(auth|jwt|oauth|session|login|password)\b/i, "authentication"],
+        [/\b(css|tailwind|styled|sass|scss|styling)\b/i, "styling"],
+        [/\b(git|merge|rebase|branch|commit)\b/i, "git"],
+        [/\b(performance|optimize|cache|lazy|memo)\b/i, "performance"],
+        [/\b(debug|error|bug|fix|issue|crash)\b/i, "debugging"],
+        [/\b(refactor|clean|architecture|pattern|design)\b/i, "architecture"],
+        [/\b(security|vulnerability|xss|csrf|injection)\b/i, "security"],
+        [/\b(ai|ml|llm|gpt|claude|model|prompt)\b/i, "ai-ml"],
+    ];
+    for (const [pattern, topic] of topicPatterns) {
+        if (pattern.test(content)) {
+            topics.add(topic);
+        }
+    }
+    return Array.from(topics);
+}
+function detectLanguages(content) {
+    const langs = new Set();
+    const langPatterns = [
+        [/```(?:typescript|tsx?)\b/i, "TypeScript"],
+        [/```(?:javascript|jsx?)\b/i, "JavaScript"],
+        [/```python\b/i, "Python"],
+        [/```rust\b/i, "Rust"],
+        [/```go\b/i, "Go"],
+        [/```java\b/i, "Java"],
+        [/```(?:c\+\+|cpp)\b/i, "C++"],
+        [/```c\b/i, "C"],
+        [/```ruby\b/i, "Ruby"],
+        [/```swift\b/i, "Swift"],
+        [/```kotlin\b/i, "Kotlin"],
+        [/```(?:bash|sh|shell|zsh)\b/i, "Shell"],
+        [/```sql\b/i, "SQL"],
+        [/```html\b/i, "HTML"],
+        [/```css\b/i, "CSS"],
+        [/```yaml\b/i, "YAML"],
+        [/```json\b/i, "JSON"],
+        [/```(?:dockerfile|docker)\b/i, "Docker"],
+    ];
+    for (const [pattern, lang] of langPatterns) {
+        if (pattern.test(content)) {
+            langs.add(lang);
+        }
+    }
+    // Also detect from imports/keywords if no code blocks
+    if (langs.size === 0) {
+        if (/\bimport\s+.*\s+from\s+['"]/.test(content))
+            langs.add("JavaScript/TypeScript");
+        if (/\bdef\s+\w+\s*\(/.test(content))
+            langs.add("Python");
+        if (/\bfn\s+\w+\s*\(/.test(content))
+            langs.add("Rust");
+        if (/\bfunc\s+\w+\s*\(/.test(content))
+            langs.add("Go");
+    }
+    return Array.from(langs);
+}
+function extractInsights(turns) {
+    const insights = [];
+    for (let i = 0; i < turns.length; i++) {
+        const turn = turns[i];
+        if (turn.role !== "assistant")
+            continue;
+        const content = turn.content;
+        // Look for key insight patterns in AI responses
+        const patterns = [
+            /(?:the (?:issue|problem|bug|root cause) (?:is|was))\s+(.{20,150})/i,
+            /(?:the (?:solution|fix|answer) (?:is|was))\s+(.{20,150})/i,
+            /(?:you (?:should|need to|can))\s+(.{20,150})/i,
+            /(?:this (?:happens|occurs) because)\s+(.{20,150})/i,
+            /(?:(?:key|important) (?:thing|point|takeaway))\s+(.{20,150})/i,
+            /(?:TIL|Today I learned|Learned that)\s+(.{20,150})/i,
+        ];
+        for (const pattern of patterns) {
+            const match = content.match(pattern);
+            if (match && match[1]) {
+                insights.push(match[1].trim().replace(/\.$/, ""));
+            }
+        }
+    }
+    // Deduplicate and limit
+    return [...new Set(insights)].slice(0, 10);
+}
+function extractCodeSnippets(content) {
+    const snippets = [];
+    const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockRegex.exec(content)) !== null) {
+        const language = match[1] || "unknown";
+        const code = match[2].trim();
+        if (code.length < 10 || code.length > 2000)
+            continue;
+        // Get surrounding context (text before the code block)
+        const beforeIdx = Math.max(0, match.index - 200);
+        const context = content.slice(beforeIdx, match.index).trim().split("\n").pop() || "";
+        snippets.push({ language, code, context });
+    }
+    return snippets.slice(0, 10);
+}
+function extractProblems(humanContent) {
+    const problems = [];
+    const lines = humanContent.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length < 15 || trimmed.length > 300)
+            continue;
+        // Look for problem indicators
+        if (/\b(error|bug|issue|problem|broken|doesn't work|not working|failing|crash|wrong)\b/i.test(trimmed) &&
+            !trimmed.startsWith("//") &&
+            !trimmed.startsWith("#")) {
+            problems.push(trimmed);
+        }
+    }
+    return [...new Set(problems)].slice(0, 5);
+}
+function extractSolutions(aiContent) {
+    const solutions = [];
+    const sentences = aiContent.split(/[.!]\s+/);
+    for (const sentence of sentences) {
+        const trimmed = sentence.trim();
+        if (trimmed.length < 20 || trimmed.length > 300)
+            continue;
+        if (/\b(fix|solve|solution|resolve|instead|should|try|change|update|replace|use)\b/i.test(trimmed) &&
+            !/\b(error|bug|issue|problem)\b/i.test(trimmed)) {
+            solutions.push(trimmed);
+        }
+    }
+    return [...new Set(solutions)].slice(0, 5);
+}
+function suggestTitle(session) {
+    const firstHuman = session.turns.find((t) => t.role === "human");
+    if (!firstHuman)
+        return `${session.source} coding session`;
+    const content = firstHuman.content.slice(0, 100);
+    // Clean up for title
+    return content
+        .replace(/\n/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function suggestTags(content) {
+    const tags = new Set();
+    // Detect specific technologies
+    const techPatterns = [
+        [/\breact\b/i, "react"],
+        [/\bnext\.?js\b/i, "nextjs"],
+        [/\btypescript\b/i, "typescript"],
+        [/\bpython\b/i, "python"],
+        [/\brust\b/i, "rust"],
+        [/\bdocker\b/i, "docker"],
+        [/\bprisma\b/i, "prisma"],
+        [/\btailwind\b/i, "tailwindcss"],
+        [/\bnode\.?js\b/i, "nodejs"],
+        [/\bgit\b/i, "git"],
+        [/\bpostgres\b/i, "postgresql"],
+        [/\bmongodb\b/i, "mongodb"],
+        [/\bredis\b/i, "redis"],
+        [/\baws\b/i, "aws"],
+        [/\bvue\b/i, "vue"],
+        [/\bangular\b/i, "angular"],
+        [/\bsvelte\b/i, "svelte"],
+        [/\bgraphql\b/i, "graphql"],
+        [/\bwebsocket\b/i, "websocket"],
+    ];
+    for (const [pattern, tag] of techPatterns) {
+        if (pattern.test(content)) {
+            tags.add(tag);
+        }
+    }
+    // Detect activity type
+    if (/\b(bug|fix|error|debug)\b/i.test(content))
+        tags.add("bug-fix");
+    if (/\b(refactor|clean|restructure)\b/i.test(content))
+        tags.add("refactoring");
+    if (/\b(performance|optimize|speed|cache)\b/i.test(content))
+        tags.add("performance");
+    if (/\b(test|spec|coverage)\b/i.test(content))
+        tags.add("testing");
+    if (/\b(deploy|ci|cd|pipeline)\b/i.test(content))
+        tags.add("devops");
+    return Array.from(tags).slice(0, 8);
+}

package/dist/lib/fs-utils.d.ts

@@ -0,0 +1,9 @@
+import * as fs from "fs";
+export declare function safeReadFile(filePath: string): string | null;
+export declare function safeReadJson<T = unknown>(filePath: string): T | null;
+export declare function safeStats(filePath: string): fs.Stats | null;
+export declare function listFiles(dir: string, extensions?: string[], recursive?: boolean): string[];
+export declare function listDirs(dir: string): string[];
+export declare function exists(p: string): boolean;
+export declare function extractProjectDescription(projectPath: string): string | null;
+export declare function readJsonl<T = unknown>(filePath: string): T[];

package/dist/lib/fs-utils.js

@@ -0,0 +1,147 @@
+import * as fs from "fs";
+import * as path from "path";
+// Safely read a file, return null on error
+export function safeReadFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+// Safely read JSON file
+export function safeReadJson(filePath) {
+    const content = safeReadFile(filePath);
+    if (!content)
+        return null;
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+// Get file stats safely
+export function safeStats(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+// List files in directory with extension filter
+export function listFiles(dir, extensions, recursive = false) {
+    if (!fs.existsSync(dir))
+        return [];
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isFile()) {
+                if (!extensions || extensions.some((ext) => entry.name.endsWith(ext))) {
+                    results.push(fullPath);
+                }
+            }
+            else if (entry.isDirectory() && recursive) {
+                results.push(...listFiles(fullPath, extensions, true));
+            }
+        }
+    }
+    catch {
+        // Permission denied or other errors
+    }
+    return results;
+}
+// List subdirectories
+export function listDirs(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => path.join(dir, e.name));
+    }
+    catch {
+        return [];
+    }
+}
+// Check if path exists
+export function exists(p) {
+    try {
+        return fs.existsSync(p);
+    }
+    catch {
+        return false;
+    }
+}
+// Extract project description from a project directory
+// Reads README.md (first paragraph) and package.json (description field)
+export function extractProjectDescription(projectPath) {
+    if (!projectPath || !fs.existsSync(projectPath))
+        return null;
+    // Try package.json first (most concise)
+    const pkgPath = path.join(projectPath, "package.json");
+    const pkg = safeReadJson(pkgPath);
+    if (pkg?.description) {
+        return pkg.description.slice(0, 200);
+    }
+    // Try README.md — extract first non-heading, non-empty paragraph
+    for (const readmeName of ["README.md", "readme.md", "Readme.md", "README.rst"]) {
+        const readmePath = path.join(projectPath, readmeName);
+        const content = safeReadFile(readmePath);
+        if (!content)
+            continue;
+        const lines = content.split("\n");
+        let desc = "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                if (desc)
+                    break;
+                continue;
+            }
+            if (trimmed.startsWith("#") || trimmed.startsWith("=") || trimmed.startsWith("-")) {
+                if (desc)
+                    break;
+                continue;
+            }
+            if (trimmed.startsWith("![") || trimmed.startsWith("<img"))
+                continue;
+            desc += (desc ? " " : "") + trimmed;
+            if (desc.length > 200)
+                break;
+        }
+        if (desc.length > 10)
+            return desc.slice(0, 300);
+    }
+    // Try Cargo.toml, pyproject.toml etc.
+    const cargoPath = path.join(projectPath, "Cargo.toml");
+    const cargo = safeReadFile(cargoPath);
+    if (cargo) {
+        const match = cargo.match(/description\s*=\s*"([^"]+)"/);
+        if (match)
+            return match[1].slice(0, 200);
+    }
+    return null;
+}
+// Read JSONL file (one JSON object per line)
+export function readJsonl(filePath) {
+    const content = safeReadFile(filePath);
+    if (!content)
+        return [];
+    return content
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((x) => x !== null);
+}

package/dist/lib/platform.d.ts

@@ -0,0 +1,6 @@
+export type Platform = "macos" | "windows" | "linux";
+export declare function getPlatform(): Platform;
+export declare function getHome(): string;
+export declare function getAppDataDir(): string;
+export declare function getLocalAppDataDir(): string;
+export declare function resolvePaths(candidates: string[]): string[];

package/dist/lib/platform.js

@@ -0,0 +1,50 @@
+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) {
+    const fs = require("fs");
+    return candidates.filter((p) => {
+        try {
+            return fs.existsSync(p);
+        }
+        catch {
+            return false;
+        }
+    });
+}

package/dist/lib/registry.d.ts

@@ -0,0 +1,13 @@
+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): 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[];
+}>;

package/dist/lib/registry.js

@@ -0,0 +1,48 @@
+// Scanner registry — all IDE scanners register here
+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);
+}
+// Scan all registered IDEs, merge and sort results
+export function scanAll(limit = 20) {
+    const allSessions = [];
+    for (const scanner of scanners) {
+        try {
+            const sessions = scanner.scan(limit);
+            allSessions.push(...sessions);
+        }
+        catch (err) {
+            // Silently skip failing scanners
+            console.error(`Scanner ${scanner.name} failed:`, err);
+        }
+    }
+    // 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 scanner.parse(filePath, maxTurns);
+}
+// List available scanners with their status
+export function listScannerStatus() {
+    return scanners.map((s) => {
+        const dirs = s.getSessionDirs();
+        return {
+            name: s.name,
+            source: s.sourceType,
+            description: s.description,
+            available: dirs.length > 0,
+            dirs,
+        };
+    });
+}

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;