@contextmirror/claude-memory 0.2.0 → 0.2.2

package/dist/mcp/server.js

@@ -13,6 +13,8 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
+import { isPro, getProFeatureMessage } from '../license/index.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
 // Tool definitions
 const tools = [
@@ -21,7 +23,12 @@ const tools = [
         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: {},
+            properties: {
+                cwd: {
+                    type: 'string',
+                    description: 'Current working directory. If provided, will check if this is a known project or a new project that needs setup.',
+                },
+            },
             required: [],
         },
     },
@@ -86,6 +93,25 @@ const tools = [
             required: ['project'],
         },
     },
+    // Pro tools
+    {
+        name: 'search_code',
+        description: '[PRO] Search for code patterns across all your projects. Find implementations, discover how you solved similar problems before. Requires Pro license.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Code pattern or text to search for',
+                },
+                filePattern: {
+                    type: 'string',
+                    description: 'File pattern to search (e.g., "*.ts", "*.py"). Optional.',
+                },
+            },
+            required: ['query'],
+        },
+    },
 ];
 function loadContext() {
     const contextPath = join(MEMORY_DIR, 'context.json');
@@ -99,19 +125,156 @@ function loadContext() {
         return null;
     }
 }
-function handleGetGlobalContext() {
+function loadConfig() {
+    const configPath = join(MEMORY_DIR, 'config.json');
+    if (!existsSync(configPath)) {
+        return DEFAULT_MEMORY_CONFIG;
+    }
+    try {
+        return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+    catch {
+        return DEFAULT_MEMORY_CONFIG;
+    }
+}
+function saveConfig(config) {
+    const configPath = join(MEMORY_DIR, 'config.json');
+    config.lastUpdated = new Date().toISOString();
+    writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+/**
+ * Check if a directory looks like a project (has project markers)
+ */
+function looksLikeProject(dir) {
+    try {
+        const entries = readdirSync(dir);
+        return (entries.includes('package.json') ||
+            entries.includes('Cargo.toml') ||
+            entries.includes('pyproject.toml') ||
+            entries.includes('go.mod') ||
+            entries.includes('.git') ||
+            entries.includes('requirements.txt'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if a path is under any of the watched directories
+ */
+function isUnderWatchedDir(path, watchedDirs) {
+    const normalizedPath = path.replace(/\/$/, '');
+    return watchedDirs.some(watchedDir => {
+        const normalizedWatched = watchedDir.replace(/\/$/, '');
+        return normalizedPath.startsWith(normalizedWatched);
+    });
+}
+/**
+ * Detect the status of the current working directory
+ */
+function detectCurrentDirectoryStatus(cwd, context, config) {
+    const normalizedCwd = cwd.replace(/\/$/, '');
+    // Check if it's a known project
+    if (context) {
+        const knownProject = context.projects.find(p => normalizedCwd === p.path.replace(/\/$/, '') ||
+            normalizedCwd.startsWith(p.path.replace(/\/$/, '') + '/'));
+        if (knownProject) {
+            return {
+                path: cwd,
+                status: 'known_project',
+                projectName: knownProject.name,
+                needsSetup: !knownProject.hasFiles.claudeMd,
+                suggestedAction: knownProject.hasFiles.claudeMd ? 'none' : 'offer_setup',
+            };
+        }
+    }
+    // Check if it's under a watched directory
+    if (config.autoDetectNewProjects && isUnderWatchedDir(cwd, config.watchedDirs)) {
+        // It's under a watched dir but not a known project
+        if (looksLikeProject(cwd)) {
+            return {
+                path: cwd,
+                status: 'new_project',
+                needsSetup: true,
+                suggestedAction: 'offer_setup',
+            };
+        }
+        else {
+            // Empty or non-project directory under watched area
+            return {
+                path: cwd,
+                status: 'new_project',
+                needsSetup: true,
+                suggestedAction: 'offer_setup',
+            };
+        }
+    }
+    // Not under watched directories
+    if (looksLikeProject(cwd)) {
+        return {
+            path: cwd,
+            status: 'outside_workspace',
+            needsSetup: false,
+            suggestedAction: 'offer_scan',
+        };
+    }
+    return {
+        path: cwd,
+        status: 'not_a_project',
+        needsSetup: false,
+        suggestedAction: 'none',
+    };
+}
+function handleGetGlobalContext(cwd) {
     const context = loadContext();
+    const config = loadConfig();
+    const lines = [];
+    // If cwd is provided, check the current directory status first
+    if (cwd) {
+        const cwdStatus = detectCurrentDirectoryStatus(cwd, context, config);
+        lines.push('# Current Directory Status');
+        lines.push('');
+        lines.push(`**Path:** ${cwdStatus.path}`);
+        lines.push(`**Status:** ${cwdStatus.status}`);
+        if (cwdStatus.projectName) {
+            lines.push(`**Project:** ${cwdStatus.projectName}`);
+        }
+        if (cwdStatus.needsSetup) {
+            lines.push(`**Needs Setup:** Yes`);
+        }
+        // Add actionable guidance for Claude
+        if (cwdStatus.suggestedAction === 'offer_setup') {
+            lines.push('');
+            lines.push('> 🆕 **New Project Detected!** This directory is not yet registered.');
+            lines.push('> Ask the user if they would like you to:');
+            lines.push('> 1. Generate a CLAUDE.md file for this project');
+            lines.push('> 2. Add this project to the memory index');
+        }
+        else if (cwdStatus.suggestedAction === 'offer_scan') {
+            lines.push('');
+            lines.push('> ℹ️ This looks like a project but is outside your watched directories.');
+            lines.push('> You may want to run `claude-memory scan` to add it.');
+        }
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+    }
     if (!context) {
-        return 'No projects scanned yet. Run `claude-memory scan` first.';
+        lines.push('No projects scanned yet. Run `claude-memory scan` first.');
+        return lines.join('\n');
     }
-    const lines = [
-        `# Your Development Environment`,
-        '',
-        `Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`,
-        '',
-        '## Active Projects',
-        '',
-    ];
+    // Check for stale data
+    const hoursSinceUpdate = (Date.now() - new Date(context.lastUpdated).getTime()) / (1000 * 60 * 60);
+    lines.push('# Your Development Environment');
+    lines.push('');
+    lines.push(`Last scanned: ${new Date(context.lastUpdated).toLocaleString()}`);
+    if (hoursSinceUpdate > 24) {
+        lines.push('');
+        lines.push(`> ⚠️ **Data may be stale** (${Math.floor(hoursSinceUpdate)} hours old). Run \`claude-memory scan\` to refresh.`);
+    }
+    lines.push('');
+    lines.push('## Active Projects');
+    lines.push('');
     // 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) {
@@ -123,6 +286,16 @@ function handleGetGlobalContext() {
         lines.push(`- **Description:** ${p.description}`);
         lines.push('');
     }
+    // Add config info
+    if (config.watchedDirs.length > 0) {
+        lines.push('## Watched Directories');
+        lines.push('');
+        for (const dir of config.watchedDirs) {
+            lines.push(`- ${dir}`);
+        }
+        lines.push('');
+        lines.push(`Auto-detect new projects: ${config.autoDetectNewProjects ? 'Yes' : 'No'}`);
+    }
     return lines.join('\n');
 }
 function handleGetProjectSummary(projectQuery) {
@@ -197,6 +370,35 @@ function handleRecordInsight(content, relatedProjects) {
         return `Failed to record insight: ${err instanceof Error ? err.message : 'Unknown error'}`;
     }
 }
+/**
+ * Pro feature: Search code across all projects
+ */
+function handleSearchCode(query, filePattern) {
+    // Check Pro license
+    if (!isPro()) {
+        return getProFeatureMessage('Cross-project code search');
+    }
+    const context = loadContext();
+    if (!context) {
+        return 'No projects scanned yet. Run `claude-memory scan` first.';
+    }
+    const lines = [
+        `# Code Search Results for "${query}"`,
+        '',
+    ];
+    // TODO: Implement actual code search
+    // For now, return a placeholder that shows the feature is gated
+    lines.push('Searching across projects:');
+    for (const p of context.projects) {
+        lines.push(`- ${p.name} (${p.path})`);
+    }
+    lines.push('');
+    lines.push(`Pattern: ${filePattern || '*'}`);
+    lines.push('');
+    lines.push('> Note: Full code search implementation coming soon.');
+    lines.push('> This will index and search actual file contents across all your projects.');
+    return lines.join('\n');
+}
 function handleGetProjectAnalysis(projectQuery) {
     const context = loadContext();
     if (!context) {
@@ -351,7 +553,7 @@ async function main() {
             let result;
             switch (name) {
                 case 'get_global_context':
-                    result = handleGetGlobalContext();
+                    result = handleGetGlobalContext(args.cwd);
                     break;
                 case 'get_project_summary':
                     result = handleGetProjectSummary(args.project);
@@ -365,6 +567,9 @@ async function main() {
                 case 'get_project_analysis':
                     result = handleGetProjectAnalysis(args.project);
                     break;
+                case 'search_code':
+                    result = handleSearchCode(args.query, args.filePattern);
+                    break;
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }

package/dist/scanner/contextGenerator.d.ts

@@ -2,12 +2,19 @@
  * Context Generator - Produces markdown context files
  */
 import { ProjectInfo, GlobalContext } from '../types/index.js';
+/**
+ * Load existing context from disk (if any)
+ */
+export declare function loadExistingContext(): GlobalContext | null;
 /**
  * Generate global context from scanned projects
+ * Preserves existing insights and user patterns
  */
 export declare function generateGlobalContext(projects: ProjectInfo[]): GlobalContext;
 /**
  * Write global context to ~/.claude-memory/
+ * Uses atomic write (write to temp, then rename) to prevent corruption
+ * Creates backup before overwriting
  */
 export declare function writeGlobalContext(context: GlobalContext): void;
 /**

package/dist/scanner/contextGenerator.js

@@ -1,38 +1,125 @@
 /**
  * Context Generator - Produces markdown context files
  */
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync, readFileSync, renameSync, unlinkSync, copyFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { SCHEMA_VERSION } from '../types/index.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
+/**
+ * Load existing context from disk (if any)
+ */
+export function loadExistingContext() {
+    const jsonPath = join(MEMORY_DIR, 'context.json');
+    if (!existsSync(jsonPath)) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(readFileSync(jsonPath, 'utf-8'));
+        return migrateContext(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Migrate old context format to current schema
+ */
+function migrateContext(data) {
+    const version = data.schemaVersion || 0;
+    // Migration from v0 (no version) to v1
+    if (version < 1) {
+        // v0 didn't have schemaVersion, excludedProjects
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            lastUpdated: data.lastUpdated || new Date().toISOString(),
+            projects: data.projects || [],
+            insights: data.insights || [],
+            userPatterns: data.userPatterns || [],
+            excludedProjects: [],
+        };
+    }
+    // Already current version
+    return data;
+}
 /**
  * Generate global context from scanned projects
+ * Preserves existing insights and user patterns
  */
 export function generateGlobalContext(projects) {
+    // Load existing context to preserve insights
+    const existing = loadExistingContext();
     return {
+        schemaVersion: SCHEMA_VERSION,
         lastUpdated: new Date().toISOString(),
         projects,
-        insights: [], // TODO: Cross-project analysis
-        userPatterns: [], // TODO: Pattern detection
+        // Preserve existing insights and patterns!
+        insights: existing?.insights || [],
+        userPatterns: existing?.userPatterns || [],
+        excludedProjects: existing?.excludedProjects || [],
     };
 }
 /**
  * Write global context to ~/.claude-memory/
+ * Uses atomic write (write to temp, then rename) to prevent corruption
+ * Creates backup before overwriting
  */
 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}`);
+    const jsonTempPath = join(MEMORY_DIR, 'context.json.tmp');
+    const mdTempPath = join(MEMORY_DIR, 'global-context.md.tmp');
+    const jsonBackupPath = join(MEMORY_DIR, 'context.json.bak');
+    try {
+        // Create backup of existing context before overwriting
+        if (existsSync(jsonPath)) {
+            try {
+                copyFileSync(jsonPath, jsonBackupPath);
+            }
+            catch {
+                // Backup failed, but continue anyway
+                console.warn('   ⚠️  Could not create backup');
+            }
+        }
+        // Write to temp files first (atomic write pattern)
+        const jsonContent = JSON.stringify(context, null, 2);
+        writeFileSync(jsonTempPath, jsonContent, 'utf-8');
+        const mdContent = formatGlobalContextMarkdown(context);
+        writeFileSync(mdTempPath, mdContent, 'utf-8');
+        // Verify JSON can be parsed back
+        const verification = JSON.parse(readFileSync(jsonTempPath, 'utf-8'));
+        if (verification.projects.length !== context.projects.length) {
+            throw new Error(`Write verification failed: expected ${context.projects.length} projects, got ${verification.projects.length}`);
+        }
+        // Atomic rename (much safer than direct write)
+        renameSync(jsonTempPath, jsonPath);
+        renameSync(mdTempPath, mdPath);
+        console.log(`\n📝 Written to:`);
+        console.log(`   ${jsonPath} (${context.projects.length} projects)`);
+        console.log(`   ${mdPath}`);
+    }
+    catch (err) {
+        // Clean up temp files if they exist
+        try {
+            if (existsSync(jsonTempPath))
+                unlinkSync(jsonTempPath);
+            if (existsSync(mdTempPath))
+                unlinkSync(mdTempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        console.error(`\n❌ Failed to write context:`);
+        console.error(`   ${err instanceof Error ? err.message : 'Unknown error'}`);
+        if (existsSync(jsonBackupPath)) {
+            console.error(`   💾 Backup available at: ${jsonBackupPath}`);
+        }
+        throw err; // Re-throw so caller knows it failed
+    }
 }
 /**
  * Format global context as markdown

package/dist/scanner/projectScanner.js

@@ -5,27 +5,61 @@ 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';
+import { loadExistingContext } from './contextGenerator.js';
 /**
  * Scan a directory for projects and extract information
  */
 export async function scanProjects(options = {}) {
     const opts = { ...DEFAULT_SCAN_OPTIONS, ...options };
     const projects = [];
+    const errors = [];
     console.log(`🔍 Scanning ${opts.rootDir} for projects...`);
+    // Verify root directory exists
+    if (!existsSync(opts.rootDir)) {
+        console.error(`❌ Directory does not exist: ${opts.rootDir}`);
+        console.error(`   Check the path and try again.`);
+        return [];
+    }
     const candidates = findProjectRoots(opts.rootDir, opts.maxDepth, opts.ignore);
-    for (const projectPath of candidates) {
+    if (candidates.length === 0) {
+        console.log(`   No project directories found in ${opts.rootDir}`);
+        console.log(`   Looking for: package.json, Cargo.toml, pyproject.toml, go.mod, or .git`);
+        return [];
+    }
+    // Load excluded projects from existing context
+    const existingContext = loadExistingContext();
+    const excludedProjects = new Set(existingContext?.excludedProjects || []);
+    // Filter out excluded projects
+    const filteredCandidates = candidates.filter(path => {
+        if (excludedProjects.has(path)) {
+            console.log(`   ⊘ Skipping excluded: ${basename(path)}`);
+            return false;
+        }
+        return true;
+    });
+    console.log(`   Found ${filteredCandidates.length} candidate directories\n`);
+    if (excludedProjects.size > 0) {
+        console.log(`   (${excludedProjects.size} excluded)\n`);
+    }
+    for (const projectPath of filteredCandidates) {
         try {
             const info = await analyzeProject(projectPath);
             if (info) {
                 projects.push(info);
-                console.log(`  ✓ Found: ${info.name} (${info.language})`);
+                console.log(`  ✓ ${info.name} (${info.language}) - ${info.techStack.join(', ') || 'no stack detected'}`);
             }
         }
         catch (err) {
-            console.warn(`  ⚠ Failed to analyze: ${projectPath}`);
+            const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+            errors.push({ path: projectPath, error: errorMsg });
+            console.warn(`  ⚠ Failed: ${basename(projectPath)} - ${errorMsg}`);
         }
     }
-    console.log(`\n📊 Found ${projects.length} projects`);
+    console.log(`\n📊 Results:`);
+    console.log(`   ✅ Successfully scanned: ${projects.length}`);
+    if (errors.length > 0) {
+        console.log(`   ⚠️  Failed to scan: ${errors.length}`);
+    }
     return projects;
 }
 /**
@@ -77,23 +111,33 @@ async function analyzeProject(projectPath) {
     const name = detectProjectName(projectPath);
     const description = detectDescription(projectPath);
     const { language, techStack } = detectTechStack(projectPath);
-    // Git info
+    // Git info with timeout to prevent hanging on large/slow repos
     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();
+            // 10 second timeout for git operations
+            const git = simpleGit(projectPath, { timeout: { block: 10000 } });
+            // Wrap in Promise.race for extra safety
+            const gitOps = async () => {
+                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();
+            };
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('Git timeout')), 10000));
+            await Promise.race([gitOps(), timeout]);
         }
-        catch {
-            // Git operations failed, use defaults
+        catch (err) {
+            // Git operations failed or timed out, use defaults
+            const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+            if (errorMsg.includes('timeout') || errorMsg.includes('Timeout')) {
+                console.warn(`   ⚠️  Git timeout for ${basename(projectPath)} - using defaults`);
+            }
         }
     }
     // Extract insights from CLAUDE.md if it exists