@contextmirror/claude-memory 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,391 @@
+/**
+ * Claude Memory MCP Server
+ *
+ * Exposes tools for Claude Code to query cross-project context:
+ * - get_global_context: Overview of all projects
+ * - get_project_summary: Details about a specific project
+ * - search_projects: Search across all projects
+ * - record_insight: Save a cross-project insight
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const MEMORY_DIR = join(homedir(), '.claude-memory');
+// Tool definitions
+const tools = [
+    {
+        name: 'get_global_context',
+        description: 'Get an overview of all projects the user is working on. Returns project names, descriptions, tech stacks, and recent activity. Use this at the start of conversations to understand the user\'s development environment.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'get_project_summary',
+        description: 'Get detailed information about a specific project. Includes description, tech stack, current branch, and any recorded insights.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: {
+                    type: 'string',
+                    description: 'Project name or partial path',
+                },
+            },
+            required: ['project'],
+        },
+    },
+    {
+        name: 'search_projects',
+        description: 'Search across all projects for mentions of a term. Useful for finding where patterns are implemented or features exist.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search term (searches names, descriptions, tech stacks)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'record_insight',
+        description: 'Record a cross-project insight or pattern for future reference. Use this when you discover something that could be useful in other projects.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'The insight to record',
+                },
+                relatedProjects: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Names of related projects',
+                },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'get_project_analysis',
+        description: 'Get deep analysis of a project for CLAUDE.md generation. Returns directory structure, README content, package.json details, and key file locations. Use this when the user asks you to generate or write a CLAUDE.md for a project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: {
+                    type: 'string',
+                    description: 'Project name or path',
+                },
+            },
+            required: ['project'],
+        },
+    },
+];
+function loadContext() {
+    const contextPath = join(MEMORY_DIR, 'context.json');
+    if (!existsSync(contextPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(contextPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function handleGetGlobalContext() {
+    const context = loadContext();
+    if (!context) {
+        return 'No projects scanned yet. Run `claude-memory scan` first.';
+    }
+    const lines = [
+        `# Your Development Environment`,
+        '',
+        `Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`,
+        '',
+        '## Active Projects',
+        '',
+    ];
+    // Sort by activity
+    const sorted = [...context.projects].sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    for (const p of sorted) {
+        const dirty = p.isDirty ? ' ⚠️' : '';
+        lines.push(`### ${p.name}${dirty}`);
+        lines.push(`- **Path:** ${p.path}`);
+        lines.push(`- **Stack:** ${p.techStack.join(', ')}`);
+        lines.push(`- **Branch:** ${p.currentBranch}`);
+        lines.push(`- **Description:** ${p.description}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function handleGetProjectSummary(projectQuery) {
+    const context = loadContext();
+    if (!context) {
+        return 'No projects scanned yet. Run `claude-memory scan` first.';
+    }
+    const project = context.projects.find((p) => p.name.toLowerCase() === projectQuery.toLowerCase() ||
+        p.path.toLowerCase().includes(projectQuery.toLowerCase()));
+    if (!project) {
+        const names = context.projects.map((p) => p.name).join(', ');
+        return `Project "${projectQuery}" not found. Known projects: ${names}`;
+    }
+    return [
+        `# ${project.name}`,
+        '',
+        `**Path:** ${project.path}`,
+        `**Language:** ${project.language}`,
+        `**Tech Stack:** ${project.techStack.join(', ')}`,
+        `**Branch:** ${project.currentBranch}${project.isDirty ? ' (uncommitted changes)' : ''}`,
+        `**Last Activity:** ${new Date(project.lastActivity).toLocaleString()}`,
+        '',
+        '## Description',
+        project.description,
+        '',
+        '## Key Files',
+        `- CLAUDE.md: ${project.hasFiles.claudeMd ? '✓ exists' : '✗ missing'}`,
+        `- README.md: ${project.hasFiles.readme ? '✓ exists' : '✗ missing'}`,
+        '',
+        project.insights.length > 0
+            ? ['## Insights', ...project.insights.map((i) => `- **${i.title}:** ${i.description}`)].join('\n')
+            : '',
+    ].join('\n');
+}
+function handleSearchProjects(query) {
+    const context = loadContext();
+    if (!context) {
+        return 'No projects scanned yet. Run `claude-memory scan` first.';
+    }
+    const q = query.toLowerCase();
+    const matches = context.projects.filter((p) => p.name.toLowerCase().includes(q) ||
+        p.description.toLowerCase().includes(q) ||
+        p.techStack.some((t) => t.toLowerCase().includes(q)));
+    if (matches.length === 0) {
+        return `No projects match "${query}".`;
+    }
+    const lines = [`# Search Results for "${query}"`, ''];
+    for (const p of matches) {
+        lines.push(`- **${p.name}** - ${p.techStack.join(', ')}`);
+        lines.push(`  ${p.description.slice(0, 100)}...`);
+    }
+    return lines.join('\n');
+}
+function handleRecordInsight(content, relatedProjects) {
+    const contextPath = join(MEMORY_DIR, 'context.json');
+    if (!existsSync(contextPath)) {
+        return 'No context file found. Run `claude-memory scan` first.';
+    }
+    try {
+        const context = JSON.parse(readFileSync(contextPath, 'utf-8'));
+        // Add the new insight
+        context.insights.push({
+            content,
+            relatedProjects: relatedProjects || [],
+            discoveredAt: new Date().toISOString(),
+        });
+        // Write back
+        writeFileSync(contextPath, JSON.stringify(context, null, 2), 'utf-8');
+        return `✅ Insight recorded: "${content.slice(0, 100)}..."${relatedProjects?.length ? ` (related to: ${relatedProjects.join(', ')})` : ''}`;
+    }
+    catch (err) {
+        return `Failed to record insight: ${err instanceof Error ? err.message : 'Unknown error'}`;
+    }
+}
+function handleGetProjectAnalysis(projectQuery) {
+    const context = loadContext();
+    if (!context) {
+        return 'No projects scanned yet. Run `claude-memory scan` first.';
+    }
+    const project = context.projects.find((p) => p.name.toLowerCase() === projectQuery.toLowerCase() ||
+        p.path.toLowerCase().includes(projectQuery.toLowerCase()));
+    if (!project) {
+        const names = context.projects.map((p) => p.name).join(', ');
+        return `Project "${projectQuery}" not found. Known projects: ${names}`;
+    }
+    const lines = [
+        '# Project Analysis for CLAUDE.md Generation',
+        '',
+        `## Basic Info`,
+        `- **Name:** ${project.name}`,
+        `- **Path:** ${project.path}`,
+        `- **Language:** ${project.language}`,
+        `- **Tech Stack:** ${project.techStack.join(', ')}`,
+        `- **Branch:** ${project.currentBranch}${project.isDirty ? ' (uncommitted changes)' : ''}`,
+        `- **Last Activity:** ${new Date(project.lastActivity).toLocaleString()}`,
+        '',
+    ];
+    // Directory structure
+    lines.push('## Directory Structure');
+    lines.push('```');
+    lines.push(getDirectoryStructure(project.path, 3));
+    lines.push('```');
+    lines.push('');
+    // README content
+    const readmePath = join(project.path, 'README.md');
+    if (existsSync(readmePath)) {
+        try {
+            const readme = readFileSync(readmePath, 'utf-8').slice(0, 3000);
+            lines.push('## README.md Content');
+            lines.push('```markdown');
+            lines.push(readme);
+            lines.push('```');
+            lines.push('');
+        }
+        catch {
+            // Skip if can't read
+        }
+    }
+    // Package.json info
+    const pkgPath = join(project.path, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            lines.push('## package.json');
+            lines.push(`- **Name:** ${pkg.name || 'unnamed'}`);
+            lines.push(`- **Description:** ${pkg.description || 'none'}`);
+            if (pkg.scripts) {
+                lines.push('- **Scripts:**');
+                for (const [name, cmd] of Object.entries(pkg.scripts)) {
+                    lines.push(`  - \`${name}\`: ${cmd}`);
+                }
+            }
+            if (pkg.dependencies) {
+                lines.push(`- **Dependencies:** ${Object.keys(pkg.dependencies).join(', ')}`);
+            }
+            lines.push('');
+        }
+        catch {
+            // Skip if can't read
+        }
+    }
+    // Key files
+    lines.push('## Key Entry Files');
+    const keyPatterns = [
+        'src/index.ts', 'src/index.js', 'src/main.ts', 'src/main.js',
+        'src/app.ts', 'src/app.js', 'src/cli.ts', 'src/cli.js',
+        'index.ts', 'index.js', 'main.ts', 'main.js',
+        'main.py', 'app.py', '__main__.py',
+        'src/lib.rs', 'src/main.rs', 'main.go',
+    ];
+    for (const pattern of keyPatterns) {
+        if (existsSync(join(project.path, pattern))) {
+            lines.push(`- ${pattern}`);
+        }
+    }
+    lines.push('');
+    lines.push('## Instructions');
+    lines.push('Based on the above analysis, please generate a CLAUDE.md file that includes:');
+    lines.push('1. Project title and one-line description');
+    lines.push('2. What the project does (2-3 sentences)');
+    lines.push('3. Tech stack overview');
+    lines.push('4. Project structure explanation');
+    lines.push('5. How to run/build');
+    lines.push('6. Any important context for future Claude sessions');
+    return lines.join('\n');
+}
+function getDirectoryStructure(dir, maxDepth, prefix = '', depth = 0) {
+    if (depth >= maxDepth)
+        return '';
+    const ignore = ['node_modules', '.git', 'dist', 'build', '__pycache__', 'target', '.next', '.nuxt', 'coverage', '.cache', '.venv', 'venv'];
+    let result = '';
+    try {
+        const entries = readdirSync(dir).filter(e => !ignore.includes(e) && !e.startsWith('.'));
+        entries.sort((a, b) => {
+            const aIsDir = statSync(join(dir, a)).isDirectory();
+            const bIsDir = statSync(join(dir, b)).isDirectory();
+            if (aIsDir && !bIsDir)
+                return -1;
+            if (!aIsDir && bIsDir)
+                return 1;
+            return a.localeCompare(b);
+        });
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            const fullPath = join(dir, entry);
+            const isLast = i === entries.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const newPrefix = prefix + (isLast ? '    ' : '│   ');
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    result += `${prefix}${connector}${entry}/\n`;
+                    result += getDirectoryStructure(fullPath, maxDepth, newPrefix, depth + 1);
+                }
+                else {
+                    result += `${prefix}${connector}${entry}\n`;
+                }
+            }
+            catch {
+                // Skip inaccessible
+            }
+        }
+    }
+    catch {
+        // Skip inaccessible
+    }
+    return result;
+}
+async function main() {
+    const server = new Server({
+        name: 'claude-memory',
+        version: '0.1.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools,
+    }));
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case 'get_global_context':
+                    result = handleGetGlobalContext();
+                    break;
+                case 'get_project_summary':
+                    result = handleGetProjectSummary(args.project);
+                    break;
+                case 'search_projects':
+                    result = handleSearchProjects(args.query);
+                    break;
+                case 'record_insight':
+                    result = handleRecordInsight(args.content, args.relatedProjects);
+                    break;
+                case 'get_project_analysis':
+                    result = handleGetProjectAnalysis(args.project);
+                    break;
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+            return {
+                content: [{ type: 'text', text: result }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Claude Memory MCP server running');
+}
+main().catch(console.error);

package/dist/scanner/contextGenerator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Context Generator - Produces markdown context files
+ */
+import { ProjectInfo, GlobalContext } from '../types/index.js';
+/**
+ * Generate global context from scanned projects
+ */
+export declare function generateGlobalContext(projects: ProjectInfo[]): GlobalContext;
+/**
+ * Write global context to ~/.claude-memory/
+ */
+export declare function writeGlobalContext(context: GlobalContext): void;
+/**
+ * Get the memory directory path
+ */
+export declare function getMemoryDir(): string;

package/dist/scanner/contextGenerator.js

@@ -0,0 +1,98 @@
+/**
+ * Context Generator - Produces markdown context files
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const MEMORY_DIR = join(homedir(), '.claude-memory');
+/**
+ * Generate global context from scanned projects
+ */
+export function generateGlobalContext(projects) {
+    return {
+        lastUpdated: new Date().toISOString(),
+        projects,
+        insights: [], // TODO: Cross-project analysis
+        userPatterns: [], // TODO: Pattern detection
+    };
+}
+/**
+ * Write global context to ~/.claude-memory/
+ */
+export function writeGlobalContext(context) {
+    // Ensure directory exists
+    if (!existsSync(MEMORY_DIR)) {
+        mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+    // Write JSON for MCP server
+    const jsonPath = join(MEMORY_DIR, 'context.json');
+    writeFileSync(jsonPath, JSON.stringify(context, null, 2));
+    // Write markdown for human readability
+    const mdPath = join(MEMORY_DIR, 'global-context.md');
+    writeFileSync(mdPath, formatGlobalContextMarkdown(context));
+    console.log(`\n📝 Written to:`);
+    console.log(`   ${jsonPath}`);
+    console.log(`   ${mdPath}`);
+}
+/**
+ * Format global context as markdown
+ */
+function formatGlobalContextMarkdown(context) {
+    const lines = [
+        '# Claude Global Memory',
+        '',
+        `> Last updated: ${new Date(context.lastUpdated).toLocaleString()}`,
+        '',
+        '## Your Projects',
+        '',
+    ];
+    // Sort by last activity (most recent first)
+    const sorted = [...context.projects].sort((a, b) => new Date(b.lastActivity).getTime() - new Date(a.lastActivity).getTime());
+    for (const project of sorted) {
+        const activityDate = new Date(project.lastActivity).toLocaleDateString();
+        const dirty = project.isDirty ? ' ⚠️ uncommitted changes' : '';
+        lines.push(`### ${project.name}`);
+        lines.push('');
+        lines.push(`**Path:** \`${project.path}\``);
+        lines.push(`**Stack:** ${project.techStack.join(', ') || 'Unknown'}`);
+        lines.push(`**Branch:** ${project.currentBranch}${dirty}`);
+        lines.push(`**Last Activity:** ${activityDate}`);
+        lines.push('');
+        lines.push(`> ${project.description}`);
+        lines.push('');
+        // Key files
+        const keyFiles = [];
+        if (project.hasFiles.claudeMd)
+            keyFiles.push('CLAUDE.md');
+        if (project.hasFiles.readme)
+            keyFiles.push('README.md');
+        if (keyFiles.length > 0) {
+            lines.push(`📄 Has: ${keyFiles.join(', ')}`);
+            lines.push('');
+        }
+        lines.push('---');
+        lines.push('');
+    }
+    // Summary stats
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(`- **Total Projects:** ${context.projects.length}`);
+    const byLanguage = context.projects.reduce((acc, p) => {
+        acc[p.language] = (acc[p.language] || 0) + 1;
+        return acc;
+    }, {});
+    lines.push(`- **Languages:** ${Object.entries(byLanguage).map(([l, c]) => `${l} (${c})`).join(', ')}`);
+    const withClaudeMd = context.projects.filter((p) => p.hasFiles.claudeMd).length;
+    lines.push(`- **With CLAUDE.md:** ${withClaudeMd}/${context.projects.length}`);
+    const dirty = context.projects.filter((p) => p.isDirty).length;
+    if (dirty > 0) {
+        lines.push(`- **⚠️ Uncommitted Changes:** ${dirty} projects`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Get the memory directory path
+ */
+export function getMemoryDir() {
+    return MEMORY_DIR;
+}

package/dist/scanner/projectScanner.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Project Scanner - Discovers and analyzes projects
+ */
+import { ProjectInfo, ScanOptions } from '../types/index.js';
+/**
+ * Scan a directory for projects and extract information
+ */
+export declare function scanProjects(options?: Partial<ScanOptions>): Promise<ProjectInfo[]>;