@contextmirror/claude-memory 0.1.0

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run build:*)",
+      "Bash(node dist/cli.js:*)",
+      "Bash(npm publish:*)",
+      "Bash(npm config set:*)"
+    ]
+  }
+}

package/README.md

@@ -0,0 +1,108 @@
+# claude-memory
+
+Cross-project memory for Claude Code. Give Claude awareness of ALL your projects, not just the one you're in.
+
+## The Problem
+
+Every Claude Code session starts fresh. Switch to a different project folder and Claude has no idea about your other work. You end up re-explaining your codebase, your patterns, your other projects.
+
+## The Solution
+
+```bash
+npm install -g claude-memory
+claude-memory scan ~/Projects
+```
+
+Now Claude knows about all your projects. Ask "What other projects do I have?" or "Generate a CLAUDE.md for this project" and Claude just knows.
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g claude-memory
+```
+
+### 2. Scan your projects
+
+```bash
+claude-memory scan ~/Projects  # or wherever your code lives
+```
+
+### 3. Add MCP to Claude Code
+
+Create `.mcp.json` in your home directory or project:
+
+```json
+{
+  "mcpServers": {
+    "claude-memory": {
+      "command": "claude-memory",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+### 4. Restart Claude Code
+
+Now Claude has access to your project memory!
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `claude-memory scan [dir]` | Scan directory for projects |
+| `claude-memory list` | List known projects |
+| `claude-memory show <project>` | Show project details |
+| `claude-memory init` | Generate CLAUDE.md for current project |
+| `claude-memory generate` | Generate CLAUDE.md for all projects |
+| `claude-memory mcp` | Start MCP server |
+
+## MCP Tools
+
+When connected, Claude Code gets these tools:
+
+| Tool | Purpose |
+|------|---------|
+| `get_global_context` | Overview of all your projects |
+| `get_project_summary` | Details about a specific project |
+| `get_project_analysis` | Deep analysis for CLAUDE.md generation |
+| `search_projects` | Search across all projects |
+| `record_insight` | Save cross-project patterns |
+
+## How It Works
+
+1. **Scan** - Finds projects by looking for package.json, Cargo.toml, pyproject.toml, .git
+2. **Extract** - Pulls name, description, tech stack, git info, CLAUDE.md content
+3. **Store** - Saves to `~/.claude-memory/context.json`
+4. **Serve** - MCP server exposes context to Claude Code
+
+## Example Usage
+
+Once set up, you can ask Claude:
+
+- "What other projects do I have?"
+- "Tell me about my CM Remake project"
+- "Generate a CLAUDE.md for this project"
+- "Which of my projects use React?"
+
+Claude will query your project memory and respond with real context.
+
+## Data Storage
+
+All data stays local:
+
+```
+~/.claude-memory/
+├── context.json        # Project metadata
+└── global-context.md   # Human-readable overview
+```
+
+## License
+
+MIT
+
+## Author
+
+Nathan (with Claude as co-developer)

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Claude Memory CLI
+ *
+ * Usage:
+ *   claude-memory scan [directory]    Scan projects and update global context
+ *   claude-memory list                List known projects
+ *   claude-memory show <project>      Show details for a project
+ *   claude-memory mcp                 Start MCP server
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * Claude Memory CLI
+ *
+ * Usage:
+ *   claude-memory scan [directory]    Scan projects and update global context
+ *   claude-memory list                List known projects
+ *   claude-memory show <project>      Show details for a project
+ *   claude-memory mcp                 Start MCP server
+ */
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { scanProjects } from './scanner/projectScanner.js';
+import { generateGlobalContext, writeGlobalContext, getMemoryDir } from './scanner/contextGenerator.js';
+const program = new Command();
+program
+    .name('claude-memory')
+    .description('Cross-project memory for Claude Code')
+    .version('0.1.0');
+// Scan command
+program
+    .command('scan')
+    .description('Scan projects and update global context')
+    .argument('[directory]', 'Root directory to scan', `${homedir()}/Project`)
+    .option('-d, --depth <number>', 'Max depth to search', '2')
+    .option('--generate-claude-md', 'Generate CLAUDE.md for projects without one')
+    .action(async (directory, options) => {
+    console.log('🧠 Claude Memory Scanner\n');
+    const projects = await scanProjects({
+        rootDir: directory,
+        maxDepth: parseInt(options.depth, 10),
+        generateClaudeMd: options.generateClaudeMd,
+    });
+    const context = generateGlobalContext(projects);
+    writeGlobalContext(context);
+    console.log('\n✅ Done! Global context updated.');
+    console.log('\nTo use with Claude Code, add the MCP server to your config:');
+    console.log('  claude-memory mcp');
+});
+// List command
+program
+    .command('list')
+    .description('List known projects')
+    .action(() => {
+    const context = loadContext();
+    if (!context) {
+        console.log('No projects scanned yet. Run: claude-memory scan');
+        return;
+    }
+    console.log('🧠 Known Projects\n');
+    for (const project of context.projects) {
+        const dirty = project.isDirty ? ' ⚠️' : '';
+        console.log(`  ${project.name}${dirty}`);
+        console.log(`    ${project.path}`);
+        console.log(`    ${project.techStack.join(', ')}`);
+        console.log('');
+    }
+});
+// Show command
+program
+    .command('show')
+    .description('Show details for a project')
+    .argument('<project>', 'Project name or path')
+    .action((projectName) => {
+    const context = loadContext();
+    if (!context) {
+        console.log('No projects scanned yet. Run: claude-memory scan');
+        return;
+    }
+    const project = context.projects.find((p) => p.name.toLowerCase() === projectName.toLowerCase() || p.path.includes(projectName));
+    if (!project) {
+        console.log(`Project not found: ${projectName}`);
+        console.log('\nKnown projects:');
+        context.projects.forEach((p) => console.log(`  - ${p.name}`));
+        return;
+    }
+    console.log(`\n📁 ${project.name}\n`);
+    console.log(`Path: ${project.path}`);
+    console.log(`Language: ${project.language}`);
+    console.log(`Stack: ${project.techStack.join(', ')}`);
+    console.log(`Branch: ${project.currentBranch}${project.isDirty ? ' (dirty)' : ''}`);
+    console.log(`Last Activity: ${new Date(project.lastActivity).toLocaleString()}`);
+    console.log(`\nDescription:\n  ${project.description}`);
+    console.log(`\nKey Files:`);
+    console.log(`  CLAUDE.md: ${project.hasFiles.claudeMd ? '✓' : '✗'}`);
+    console.log(`  README.md: ${project.hasFiles.readme ? '✓' : '✗'}`);
+});
+// Init command - shows how to generate CLAUDE.md
+program
+    .command('init')
+    .description('Generate CLAUDE.md for the current project')
+    .action(async () => {
+    const projectPath = process.cwd();
+    console.log('🧠 Claude Memory - CLAUDE.md Generator\n');
+    console.log(`📁 Project: ${projectPath}\n`);
+    // Quick analysis of current project
+    const projects = await scanProjects({
+        rootDir: projectPath,
+        maxDepth: 0,
+    });
+    if (projects.length === 0) {
+        console.log('❌ No project detected in current directory');
+        console.log('   (Looking for package.json, Cargo.toml, pyproject.toml, or .git)');
+        return;
+    }
+    const project = projects[0];
+    console.log(`✅ Found project: ${project.name}`);
+    console.log(`   Language: ${project.language}`);
+    console.log(`   Stack: ${project.techStack.join(', ')}`);
+    console.log(`   Has CLAUDE.md: ${project.hasFiles.claudeMd ? 'Yes' : 'No'}`);
+    console.log('\n📝 To generate a CLAUDE.md file:');
+    console.log('   1. Open this project in Claude Code');
+    console.log('   2. Ask Claude: "Generate a CLAUDE.md for this project"');
+    console.log('   3. Claude will use the MCP tools to analyze and write it');
+    console.log('\n💡 This uses your existing Claude session - no extra API costs!');
+});
+// MCP command - start the MCP server
+program
+    .command('mcp')
+    .description('Start MCP server for Claude Code integration')
+    .action(async () => {
+    // Import and run the MCP server
+    await import('./mcp/server.js');
+});
+function loadContext() {
+    const contextPath = join(getMemoryDir(), 'context.json');
+    if (!existsSync(contextPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(readFileSync(contextPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+program.parse();

package/dist/generator/claudeMdGenerator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CLAUDE.md Generator
+ *
+ * Analyzes a project and generates a CLAUDE.md file using Claude API
+ */
+import { ProjectInfo } from '../types/index.js';
+/**
+ * Generate a CLAUDE.md file for a project
+ */
+export declare function generateClaudeMd(projectPath: string, projectInfo: ProjectInfo, options?: {
+    overwrite?: boolean;
+    dryRun?: boolean;
+}): Promise<string>;
+/**
+ * Generate CLAUDE.md for multiple projects
+ */
+export declare function generateClaudeMdBatch(projects: ProjectInfo[], options?: {
+    overwrite?: boolean;
+    dryRun?: boolean;
+}): Promise<Map<string, string>>;

package/dist/generator/claudeMdGenerator.js

@@ -0,0 +1,202 @@
+/**
+ * CLAUDE.md Generator
+ *
+ * Analyzes a project and generates a CLAUDE.md file using Claude API
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Generate a CLAUDE.md file for a project
+ */
+export async function generateClaudeMd(projectPath, projectInfo, options = {}) {
+    const claudeMdPath = join(projectPath, 'CLAUDE.md');
+    // Check if CLAUDE.md already exists
+    if (existsSync(claudeMdPath) && !options.overwrite) {
+        console.log(`  ⏭️  Skipping ${projectInfo.name} - CLAUDE.md already exists`);
+        return readFileSync(claudeMdPath, 'utf-8');
+    }
+    console.log(`  🔍 Analyzing ${projectInfo.name}...`);
+    // Gather project information
+    const analysis = analyzeProjectDeep(projectPath, projectInfo);
+    console.log(`  🤖 Generating CLAUDE.md...`);
+    // Generate CLAUDE.md content using Claude
+    const content = await callClaudeForGeneration(analysis);
+    if (options.dryRun) {
+        console.log(`  📝 [Dry run] Would write CLAUDE.md`);
+        return content;
+    }
+    // Write the file
+    writeFileSync(claudeMdPath, content, 'utf-8');
+    console.log(`  ✅ Created CLAUDE.md for ${projectInfo.name}`);
+    return content;
+}
+/**
+ * Deep analysis of a project for CLAUDE.md generation
+ */
+function analyzeProjectDeep(projectPath, projectInfo) {
+    // Get directory structure (limited depth)
+    const structure = getDirectoryStructure(projectPath, 3);
+    // Read README if exists
+    let readme = null;
+    const readmePath = join(projectPath, 'README.md');
+    if (existsSync(readmePath)) {
+        readme = readFileSync(readmePath, 'utf-8').slice(0, 3000); // Limit size
+    }
+    // Read package.json / pyproject.toml / Cargo.toml
+    let packageInfo = null;
+    const pkgPath = join(projectPath, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            packageInfo = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        }
+        catch {
+            // Invalid JSON
+        }
+    }
+    // Find key files
+    const keyFiles = findKeyFiles(projectPath);
+    return {
+        name: projectInfo.name,
+        description: projectInfo.description,
+        techStack: projectInfo.techStack,
+        structure,
+        readme,
+        packageInfo,
+        keyFiles,
+        recentCommits: [], // TODO: Add git log
+    };
+}
+/**
+ * Get directory structure as a string tree
+ */
+function getDirectoryStructure(dir, maxDepth, prefix = '', depth = 0) {
+    if (depth >= maxDepth)
+        return '';
+    const ignore = ['node_modules', '.git', 'dist', 'build', '__pycache__', 'target', '.next', '.nuxt', 'coverage', '.cache'];
+    let result = '';
+    try {
+        const entries = readdirSync(dir).filter(e => !ignore.includes(e) && !e.startsWith('.'));
+        entries.sort((a, b) => {
+            // Directories first
+            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;
+}
+/**
+ * Find key files in the project
+ */
+function findKeyFiles(projectPath) {
+    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', 'app.ts', 'app.js',
+        'main.py', 'app.py', '__main__.py',
+        'src/lib.rs', 'src/main.rs',
+        'main.go', 'cmd/main.go',
+    ];
+    const found = [];
+    for (const pattern of keyPatterns) {
+        if (existsSync(join(projectPath, pattern))) {
+            found.push(pattern);
+        }
+    }
+    return found;
+}
+/**
+ * Call Claude API to generate CLAUDE.md content
+ */
+async function callClaudeForGeneration(analysis) {
+    const client = new Anthropic();
+    const prompt = `You are generating a CLAUDE.md file for a software project. This file helps future Claude Code sessions understand the project quickly.
+
+PROJECT INFO:
+- Name: ${analysis.name}
+- Description: ${analysis.description}
+- Tech Stack: ${analysis.techStack.join(', ')}
+- Key entry files: ${analysis.keyFiles.join(', ') || 'None detected'}
+
+DIRECTORY STRUCTURE:
+${analysis.structure || 'Not available'}
+
+${analysis.readme ? `README CONTENT:\n${analysis.readme}\n` : ''}
+
+${analysis.packageInfo ? `PACKAGE.JSON SCRIPTS:\n${JSON.stringify(analysis.packageInfo.scripts || {}, null, 2)}\n` : ''}
+
+Generate a CLAUDE.md file that includes:
+1. A brief project title and one-line description
+2. What the project does (2-3 sentences max)
+3. Tech stack overview
+4. Project structure explanation (key directories)
+5. How to run/build (based on package.json scripts or standard conventions)
+6. Any important notes for Claude sessions
+
+Keep it concise - this is a quick reference, not documentation. Use markdown formatting.
+Do NOT include placeholder text like "[Add X here]" - only include sections you have real information for.
+Start the file with "# ${analysis.name}" as the title.`;
+    const response = await client.messages.create({
+        model: 'claude-sonnet-4-20250514',
+        max_tokens: 2000,
+        messages: [
+            { role: 'user', content: prompt }
+        ]
+    });
+    // Extract text from response
+    const textBlock = response.content.find(block => block.type === 'text');
+    if (!textBlock || textBlock.type !== 'text') {
+        throw new Error('No text response from Claude');
+    }
+    return textBlock.text;
+}
+/**
+ * Generate CLAUDE.md for multiple projects
+ */
+export async function generateClaudeMdBatch(projects, options = {}) {
+    const results = new Map();
+    const needsGeneration = projects.filter(p => !p.hasFiles.claudeMd || options.overwrite);
+    if (needsGeneration.length === 0) {
+        console.log('All projects already have CLAUDE.md files');
+        return results;
+    }
+    console.log(`\n📝 Generating CLAUDE.md for ${needsGeneration.length} projects...\n`);
+    for (const project of needsGeneration) {
+        try {
+            const content = await generateClaudeMd(project.path, project, options);
+            results.set(project.path, content);
+        }
+        catch (err) {
+            console.error(`  ❌ Failed to generate for ${project.name}:`, err);
+        }
+    }
+    return results;
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+export {};