@contextmirror/claude-memory 0.3.1 → 0.4.1

package/README.md

@@ -9,18 +9,27 @@ Every Claude Code session starts fresh. Switch to a different project folder and
 ## The Solution
 
 ```bash
-npm install -g claude-memory
+npm install -g @contextmirror/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.
 
+## Features
+
+- **Cross-project awareness** - Claude knows about all your projects
+- **Staleness detection** - Automatically detects when projects need rescanning
+- **Quick scans** - Only rescan projects that have changed
+- **Update notifications** - Get notified when new versions are available
+- **CLAUDE.md generation** - Auto-generate project documentation
+- **MCP integration** - Works seamlessly with Claude Code
+
 ## Quick Start
 
 ### 1. Install
 
 ```bash
-npm install -g claude-memory
+npm install -g @contextmirror/claude-memory
 ```
 
 ### 2. Scan your projects
@@ -53,11 +62,39 @@ Now Claude has access to your project memory!
 | Command | Description |
 |---------|-------------|
 | `claude-memory scan [dir]` | Scan directory for projects |
+| `claude-memory scan --quick` | Only rescan stale projects (faster) |
+| `claude-memory scan --check` | Check what's stale without scanning |
 | `claude-memory list` | List known projects |
 | `claude-memory show <project>` | Show project details |
+| `claude-memory briefing [dir]` | Generate CLAUDE.md for a project |
 | `claude-memory init` | Generate CLAUDE.md for current project |
-| `claude-memory generate` | Generate CLAUDE.md for all projects |
+| `claude-memory exclude <project>` | Exclude project from future scans |
+| `claude-memory include <project>` | Re-include an excluded project |
 | `claude-memory mcp` | Start MCP server |
+| `claude-memory setup` | Interactive setup wizard |
+
+## Staleness Detection
+
+claude-memory automatically detects when your projects need rescanning:
+
+```bash
+# Check what's stale
+claude-memory scan --check
+
+# Output:
+# 🧠 Claude Memory - Staleness Check
+#
+# ⚠️  2 project(s) need updating:
+#   📝 my-project (New commits since last scan)
+#   📄 another-project (Key files modified since last scan)
+#
+# Run `claude-memory scan --quick` to refresh only stale projects.
+```
+
+**Detection methods:**
+- **Git activity** - New commits since last scan
+- **File changes** - package.json, CLAUDE.md, etc. modified
+- **Age** - Projects not scanned in 7+ days
 
 ## MCP Tools
 
@@ -65,11 +102,25 @@ When connected, Claude Code gets these tools:
 
 | Tool | Purpose |
 |------|---------|
-| `get_global_context` | Overview of all your projects |
+| `get_global_context` | Overview of all your projects + staleness info |
 | `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 |
+| `search_code` | **[Pro]** Search code across all projects |
+
+## Update Notifications
+
+claude-memory checks for updates automatically (once per day, cached). When a new version is available, Claude will see:
+
+```
+⬆️ Update available: v0.3.0 → v0.4.0
+
+Run to update:
+npm update -g @contextmirror/claude-memory
+
+After updating, restart Claude Code to use the new version.
+```
 
 ## How It Works
 
@@ -77,15 +128,17 @@ When connected, Claude Code gets these tools:
 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
+5. **Detect** - Monitors for staleness on each session start
 
 ## Example Usage
 
 Once set up, you can ask Claude:
 
 - "What other projects do I have?"
-- "Tell me about my CM Remake project"
+- "Tell me about my project X"
 - "Generate a CLAUDE.md for this project"
 - "Which of my projects use React?"
+- "Is my project data up to date?"
 
 Claude will query your project memory and respond with real context.
 
@@ -96,9 +149,22 @@ All data stays local:
 ```
 ~/.claude-memory/
 ├── context.json        # Project metadata
-└── global-context.md   # Human-readable overview
+├── context.json.bak    # Backup
+├── global-context.md   # Human-readable overview
+├── config.json         # User configuration
+├── update-check.json   # Update check cache
+└── license.json        # Pro license (if activated)
 ```
 
+## Pro Features
+
+Activate with `claude-memory activate <key>`. Get a license at https://claude-memory.dev
+
+| Feature | Description |
+|---------|-------------|
+| Cross-project code search | Search code patterns across all your projects |
+| Semantic search | Search by meaning, not just keywords (coming soon) |
+
 ## License
 
 MIT
@@ -106,3 +172,7 @@ MIT
 ## Author
 
 Nathan (with Claude as co-developer)
+
+---
+
+*Part of the [Context Mirror](https://github.com/contextmirror) project*

package/dist/mcp/server.js

@@ -16,8 +16,9 @@ import { homedir } from 'os';
 import { DEFAULT_MEMORY_CONFIG } from '../types/index.js';
 import { isPro, getProFeatureMessage } from '../license/index.js';
 import { detectStaleProjects, checkCurrentProjectStaleness, formatStalenessForMcp } from '../scanner/stalenessDetector.js';
+import { checkForUpdate, formatUpdateMessage } from '../utils/updateChecker.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
-const CURRENT_VERSION = '0.3.0'; // Update this with each release
+const CURRENT_VERSION = '0.4.0'; // Update this with each release
 // Tool definitions
 const tools = [
     {
@@ -227,10 +228,16 @@ function detectCurrentDirectoryStatus(cwd, context, config) {
         suggestedAction: 'none',
     };
 }
-function handleGetGlobalContext(cwd) {
+async function handleGetGlobalContext(cwd) {
     const context = loadContext();
     const config = loadConfig();
     const lines = [];
+    // Check for updates (cached, won't block)
+    const updateResult = await checkForUpdate(CURRENT_VERSION);
+    if (updateResult.updateAvailable) {
+        lines.push(formatUpdateMessage(updateResult));
+        lines.push('');
+    }
     // If cwd is provided, check the current directory status first
     if (cwd) {
         const cwdStatus = detectCurrentDirectoryStatus(cwd, context, config);
@@ -569,7 +576,7 @@ async function main() {
             let result;
             switch (name) {
                 case 'get_global_context':
-                    result = handleGetGlobalContext(args.cwd);
+                    result = await handleGetGlobalContext(args.cwd);
                     break;
                 case 'get_project_summary':
                     result = handleGetProjectSummary(args.project);

package/dist/utils/updateChecker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Update checker for claude-memory
+ * Checks npm registry for newer versions and caches result
+ */
+interface UpdateCheckResult {
+    updateAvailable: boolean;
+    currentVersion: string;
+    latestVersion: string | null;
+    message?: string;
+}
+/**
+ * Check if an update is available
+ * Uses cache to avoid checking too frequently
+ */
+export declare function checkForUpdate(currentVersion: string): Promise<UpdateCheckResult>;
+/**
+ * Format update message for MCP output
+ */
+export declare function formatUpdateMessage(result: UpdateCheckResult): string;
+export {};

package/dist/utils/updateChecker.js

@@ -0,0 +1,155 @@
+/**
+ * Update checker for claude-memory
+ * Checks npm registry for newer versions and caches result
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import https from 'https';
+const MEMORY_DIR = join(homedir(), '.claude-memory');
+const UPDATE_CACHE_FILE = join(MEMORY_DIR, 'update-check.json');
+const PACKAGE_NAME = '@contextmirror/claude-memory';
+const CHECK_INTERVAL_HOURS = 24; // Check once per day
+/**
+ * Fetch the latest version from npm registry
+ */
+function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const url = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+        const req = https.get(url, { timeout: 5000 }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version || null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on('error', () => {
+            resolve(null);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(null);
+        });
+    });
+}
+/**
+ * Load cached update check result
+ */
+function loadCache() {
+    try {
+        if (existsSync(UPDATE_CACHE_FILE)) {
+            return JSON.parse(readFileSync(UPDATE_CACHE_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Save update check result to cache
+ */
+function saveCache(cache) {
+    try {
+        if (!existsSync(MEMORY_DIR)) {
+            mkdirSync(MEMORY_DIR, { recursive: true });
+        }
+        writeFileSync(UPDATE_CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Compare semantic versions
+ * Returns true if latestVersion is newer than currentVersion
+ */
+function isNewer(currentVersion, latestVersion) {
+    const current = currentVersion.split('.').map(Number);
+    const latest = latestVersion.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((latest[i] || 0) > (current[i] || 0))
+            return true;
+        if ((latest[i] || 0) < (current[i] || 0))
+            return false;
+    }
+    return false;
+}
+/**
+ * Check if an update is available
+ * Uses cache to avoid checking too frequently
+ */
+export async function checkForUpdate(currentVersion) {
+    const cache = loadCache();
+    const now = new Date();
+    // Check if we have a recent cache
+    if (cache) {
+        const lastChecked = new Date(cache.lastChecked);
+        const hoursSinceCheck = (now.getTime() - lastChecked.getTime()) / (1000 * 60 * 60);
+        if (hoursSinceCheck < CHECK_INTERVAL_HOURS && cache.latestVersion) {
+            // Use cached result
+            const updateAvailable = isNewer(currentVersion, cache.latestVersion);
+            return {
+                updateAvailable,
+                currentVersion,
+                latestVersion: cache.latestVersion,
+                message: updateAvailable
+                    ? `⬆️ Update available: v${currentVersion} → v${cache.latestVersion}`
+                    : undefined,
+            };
+        }
+    }
+    // Fetch fresh version info
+    const latestVersion = await fetchLatestVersion();
+    // Save to cache
+    saveCache({
+        lastChecked: now.toISOString(),
+        latestVersion,
+        currentVersion,
+    });
+    if (!latestVersion) {
+        return {
+            updateAvailable: false,
+            currentVersion,
+            latestVersion: null,
+        };
+    }
+    const updateAvailable = isNewer(currentVersion, latestVersion);
+    return {
+        updateAvailable,
+        currentVersion,
+        latestVersion,
+        message: updateAvailable
+            ? `⬆️ Update available: v${currentVersion} → v${latestVersion}`
+            : undefined,
+    };
+}
+/**
+ * Format update message for MCP output
+ */
+export function formatUpdateMessage(result) {
+    if (!result.updateAvailable || !result.latestVersion) {
+        return '';
+    }
+    return [
+        '',
+        '---',
+        '',
+        `### ${result.message}`,
+        '',
+        'Run to update:',
+        '```bash',
+        'npm update -g @contextmirror/claude-memory',
+        '```',
+        '',
+        '> After updating, restart Claude Code to use the new version.',
+    ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextmirror/claude-memory",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Cross-project memory for Claude Code - know about all your projects",
   "type": "module",
   "main": "dist/cli.js",