@contextmirror/claude-memory 0.1.0

package/dist/scanner/projectScanner.js

@@ -0,0 +1,319 @@
+/**
+ * Project Scanner - Discovers and analyzes projects
+ */
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { simpleGit } from 'simple-git';
+import { DEFAULT_SCAN_OPTIONS } from '../types/index.js';
+/**
+ * Scan a directory for projects and extract information
+ */
+export async function scanProjects(options = {}) {
+    const opts = { ...DEFAULT_SCAN_OPTIONS, ...options };
+    const projects = [];
+    console.log(`🔍 Scanning ${opts.rootDir} for projects...`);
+    const candidates = findProjectRoots(opts.rootDir, opts.maxDepth, opts.ignore);
+    for (const projectPath of candidates) {
+        try {
+            const info = await analyzeProject(projectPath);
+            if (info) {
+                projects.push(info);
+                console.log(`  ✓ Found: ${info.name} (${info.language})`);
+            }
+        }
+        catch (err) {
+            console.warn(`  ⚠ Failed to analyze: ${projectPath}`);
+        }
+    }
+    console.log(`\n📊 Found ${projects.length} projects`);
+    return projects;
+}
+/**
+ * Find directories that look like project roots
+ */
+function findProjectRoots(rootDir, maxDepth, ignore) {
+    const roots = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = readdirSync(dir);
+            // Check if this is a project root
+            const isProject = entries.includes('package.json') ||
+                entries.includes('Cargo.toml') ||
+                entries.includes('pyproject.toml') ||
+                entries.includes('go.mod') ||
+                entries.includes('.git');
+            if (isProject) {
+                roots.push(dir);
+                return; // Don't recurse into project subdirectories
+            }
+            // Recurse into subdirectories
+            for (const entry of entries) {
+                if (ignore.includes(entry))
+                    continue;
+                const fullPath = join(dir, entry);
+                try {
+                    if (statSync(fullPath).isDirectory()) {
+                        walk(fullPath, depth + 1);
+                    }
+                }
+                catch {
+                    // Skip inaccessible directories
+                }
+            }
+        }
+        catch {
+            // Skip inaccessible directories
+        }
+    }
+    walk(rootDir, 0);
+    return roots;
+}
+/**
+ * Analyze a single project
+ */
+async function analyzeProject(projectPath) {
+    const name = detectProjectName(projectPath);
+    const description = detectDescription(projectPath);
+    const { language, techStack } = detectTechStack(projectPath);
+    // Git info
+    let lastActivity = new Date().toISOString();
+    let currentBranch = 'unknown';
+    let isDirty = false;
+    if (existsSync(join(projectPath, '.git'))) {
+        try {
+            const git = simpleGit(projectPath);
+            const log = await git.log({ maxCount: 1 });
+            if (log.latest) {
+                lastActivity = log.latest.date;
+            }
+            const status = await git.status();
+            currentBranch = status.current || 'unknown';
+            isDirty = !status.isClean();
+        }
+        catch {
+            // Git operations failed, use defaults
+        }
+    }
+    // Extract insights from CLAUDE.md if it exists
+    const insights = extractInsightsFromClaudeMd(projectPath);
+    return {
+        path: projectPath,
+        name,
+        description,
+        techStack,
+        language,
+        lastActivity,
+        currentBranch,
+        isDirty,
+        hasFiles: {
+            claudeMd: existsSync(join(projectPath, 'CLAUDE.md')),
+            readme: existsSync(join(projectPath, 'README.md')),
+            packageJson: existsSync(join(projectPath, 'package.json')),
+            gitignore: existsSync(join(projectPath, '.gitignore')),
+        },
+        insights,
+        lastScanned: new Date().toISOString(),
+    };
+}
+/**
+ * Detect project name from various sources
+ */
+function detectProjectName(projectPath) {
+    // Try package.json
+    const pkgPath = join(projectPath, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (pkg.name)
+                return pkg.name;
+        }
+        catch {
+            // Invalid JSON
+        }
+    }
+    // Try Cargo.toml
+    const cargoPath = join(projectPath, 'Cargo.toml');
+    if (existsSync(cargoPath)) {
+        try {
+            const cargo = readFileSync(cargoPath, 'utf-8');
+            const match = cargo.match(/name\s*=\s*"([^"]+)"/);
+            if (match)
+                return match[1];
+        }
+        catch {
+            // Read failed
+        }
+    }
+    // Fall back to folder name
+    return basename(projectPath);
+}
+/**
+ * Detect project description
+ */
+function detectDescription(projectPath) {
+    // Try package.json
+    const pkgPath = join(projectPath, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (pkg.description)
+                return pkg.description;
+        }
+        catch {
+            // Invalid JSON
+        }
+    }
+    // Try README first line
+    const readmePath = join(projectPath, 'README.md');
+    if (existsSync(readmePath)) {
+        try {
+            const readme = readFileSync(readmePath, 'utf-8');
+            const lines = readme.split('\n').filter((l) => l.trim() && !l.startsWith('#'));
+            if (lines[0])
+                return lines[0].slice(0, 200);
+        }
+        catch {
+            // Read failed
+        }
+    }
+    // Try CLAUDE.md first paragraph
+    const claudePath = join(projectPath, 'CLAUDE.md');
+    if (existsSync(claudePath)) {
+        try {
+            const claude = readFileSync(claudePath, 'utf-8');
+            const match = claude.match(/##\s*Project Overview\s*\n+([^\n]+)/i);
+            if (match)
+                return match[1].slice(0, 200);
+        }
+        catch {
+            // Read failed
+        }
+    }
+    return 'No description available';
+}
+/**
+ * Detect tech stack and primary language
+ */
+function detectTechStack(projectPath) {
+    const techStack = [];
+    let language = 'other';
+    // Check package.json
+    const pkgPath = join(projectPath, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Detect TypeScript
+            if (deps.typescript || existsSync(join(projectPath, 'tsconfig.json'))) {
+                language = 'typescript';
+                techStack.push('TypeScript');
+            }
+            else {
+                language = 'javascript';
+                techStack.push('JavaScript');
+            }
+            // Detect frameworks
+            if (deps.react)
+                techStack.push('React');
+            if (deps.vue)
+                techStack.push('Vue');
+            if (deps.next)
+                techStack.push('Next.js');
+            if (deps.express)
+                techStack.push('Express');
+            if (deps.fastify)
+                techStack.push('Fastify');
+            if (deps['@anthropic-ai/sdk'])
+                techStack.push('Claude SDK');
+            if (deps['@modelcontextprotocol/sdk'])
+                techStack.push('MCP');
+        }
+        catch {
+            // Invalid JSON
+        }
+    }
+    // Check Cargo.toml
+    if (existsSync(join(projectPath, 'Cargo.toml'))) {
+        language = 'rust';
+        techStack.push('Rust');
+    }
+    // Check pyproject.toml or requirements.txt
+    if (existsSync(join(projectPath, 'pyproject.toml')) ||
+        existsSync(join(projectPath, 'requirements.txt'))) {
+        language = 'python';
+        techStack.push('Python');
+    }
+    // Check go.mod
+    if (existsSync(join(projectPath, 'go.mod'))) {
+        language = 'go';
+        techStack.push('Go');
+    }
+    return { language, techStack };
+}
+/**
+ * Extract insights from CLAUDE.md file
+ * Looks for patterns like:
+ * - ## Session Context / ## Current State sections
+ * - Key architectural decisions
+ * - TODOs and next steps
+ */
+function extractInsightsFromClaudeMd(projectPath) {
+    const claudePath = join(projectPath, 'CLAUDE.md');
+    if (!existsSync(claudePath)) {
+        return [];
+    }
+    const insights = [];
+    try {
+        const content = readFileSync(claudePath, 'utf-8');
+        // Extract "Session Context" or "Current State" sections
+        const sessionMatch = content.match(/##\s*(Session Context|Current State|Where we left off)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+        if (sessionMatch) {
+            insights.push({
+                type: 'notable',
+                title: 'Session Context',
+                description: sessionMatch[2].trim().slice(0, 500),
+                source: 'CLAUDE.md',
+                discoveredAt: new Date().toISOString(),
+            });
+        }
+        // Extract "What's Been Built" or similar sections
+        const builtMatch = content.match(/##\s*(What's Been Built|Features|Implemented)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+        if (builtMatch) {
+            insights.push({
+                type: 'architecture',
+                title: 'What\'s Built',
+                description: builtMatch[2].trim().slice(0, 500),
+                source: 'CLAUDE.md',
+                discoveredAt: new Date().toISOString(),
+            });
+        }
+        // Extract "Next Steps" or "TODO" sections
+        const todoMatch = content.match(/##\s*(Next Steps|TODO|Roadmap|Immediate)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+        if (todoMatch) {
+            insights.push({
+                type: 'todo',
+                title: 'Next Steps',
+                description: todoMatch[2].trim().slice(0, 500),
+                source: 'CLAUDE.md',
+                discoveredAt: new Date().toISOString(),
+            });
+        }
+        // Extract architecture/tech decisions
+        const archMatch = content.match(/##\s*(Architecture|Tech Stack|Design)[^\n]*\n([\s\S]*?)(?=\n##|$)/i);
+        if (archMatch) {
+            insights.push({
+                type: 'architecture',
+                title: 'Architecture',
+                description: archMatch[2].trim().slice(0, 500),
+                source: 'CLAUDE.md',
+                discoveredAt: new Date().toISOString(),
+            });
+        }
+    }
+    catch {
+        // Failed to read or parse
+    }
+    return insights;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Core types for Claude Memory
+ */
+export interface ProjectInfo {
+    /** Absolute path to project root */
+    path: string;
+    /** Project name (from package.json, Cargo.toml, or folder name) */
+    name: string;
+    /** Short description (from package.json, README first line, etc.) */
+    description: string;
+    /** Detected tech stack */
+    techStack: string[];
+    /** Primary language */
+    language: 'typescript' | 'javascript' | 'python' | 'rust' | 'go' | 'other';
+    /** Last git commit date */
+    lastActivity: string;
+    /** Current git branch */
+    currentBranch: string;
+    /** Has uncommitted changes */
+    isDirty: boolean;
+    /** Key files that exist */
+    hasFiles: {
+        claudeMd: boolean;
+        readme: boolean;
+        packageJson: boolean;
+        gitignore: boolean;
+    };
+    /** Extracted insights (patterns, conventions, notable things) */
+    insights: ProjectInsight[];
+    /** When this project was last scanned */
+    lastScanned: string;
+}
+export interface ProjectInsight {
+    /** What kind of insight */
+    type: 'pattern' | 'convention' | 'architecture' | 'notable' | 'todo';
+    /** Short title */
+    title: string;
+    /** Description */
+    description: string;
+    /** Source file (if applicable) */
+    source?: string;
+    /** When discovered */
+    discoveredAt: string;
+}
+export interface GlobalContext {
+    /** When the global context was last updated */
+    lastUpdated: string;
+    /** All scanned projects */
+    projects: ProjectInfo[];
+    /** Cross-project insights */
+    insights: GlobalInsight[];
+    /** User preferences/patterns observed */
+    userPatterns: UserPattern[];
+}
+export interface GlobalInsight {
+    /** Insight content */
+    content: string;
+    /** Which projects this relates to */
+    relatedProjects: string[];
+    /** When discovered */
+    discoveredAt: string;
+}
+export interface UserPattern {
+    /** Pattern name */
+    name: string;
+    /** Description */
+    description: string;
+    /** Examples from projects */
+    examples: Array<{
+        project: string;
+        file: string;
+        snippet?: string;
+    }>;
+}
+export interface ScanOptions {
+    /** Root directory to scan (default: ~/Projects) */
+    rootDir: string;
+    /** Max depth to search for projects */
+    maxDepth: number;
+    /** Patterns to ignore */
+    ignore: string[];
+    /** Whether to generate CLAUDE.md files */
+    generateClaudeMd: boolean;
+    /** Whether to overwrite existing CLAUDE.md */
+    overwriteClaudeMd: boolean;
+}
+export declare const DEFAULT_SCAN_OPTIONS: ScanOptions;

package/dist/types/index.js

@@ -0,0 +1,10 @@
+/**
+ * Core types for Claude Memory
+ */
+export const DEFAULT_SCAN_OPTIONS = {
+    rootDir: process.env.HOME ? `${process.env.HOME}/Project` : './projects',
+    maxDepth: 2,
+    ignore: ['node_modules', '.git', 'dist', 'build', '__pycache__', 'target'],
+    generateClaudeMd: false,
+    overwriteClaudeMd: false,
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@contextmirror/claude-memory",
+  "version": "0.1.0",
+  "description": "Cross-project memory for Claude Code - know about all your projects",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "claude-memory": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "scan": "node dist/cli.js scan",
+    "mcp": "node dist/mcp/server.js",
+    "test": "vitest"
+  },
+  "keywords": [
+    "claude",
+    "mcp",
+    "memory",
+    "context",
+    "ai"
+  ],
+  "author": "Nathan",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^12.1.0",
+    "glob": "^11.0.0",
+    "simple-git": "^3.27.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}