@contextmirror/claude-memory 0.2.1 → 0.3.0

package/dist/cli.js

@@ -16,6 +16,8 @@ import { scanProjects } from './scanner/projectScanner.js';
 import { generateGlobalContext, writeGlobalContext, getMemoryDir } from './scanner/contextGenerator.js';
 import { generateBriefing, briefingToClaudeMd } from './briefing/briefingGenerator.js';
 import { runSetupWizard } from './setup/setupWizard.js';
+import { activateLicense, deactivateLicense, getLicenseStatus } from './license/index.js';
+import { detectStaleProjects } from './scanner/stalenessDetector.js';
 const program = new Command();
 program
     .name('claude-memory')
@@ -28,14 +30,83 @@ program
     .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')
+    .option('-q, --quick', 'Only rescan stale projects (faster)')
+    .option('--check', 'Only check for stale projects, don\'t scan')
     .action(async (directory, options) => {
+    // Check-only mode: just report staleness
+    if (options.check) {
+        const context = loadContext();
+        if (!context) {
+            console.log('No projects scanned yet. Run: claude-memory scan');
+            return;
+        }
+        const report = detectStaleProjects(context);
+        console.log('🧠 Claude Memory - Staleness Check\n');
+        console.log(`Last full scan: ${new Date(context.lastUpdated).toLocaleString()}`);
+        console.log(`Data age: ${report.dataAgeHours} hours\n`);
+        if (report.staleProjects.length === 0) {
+            console.log('✅ All projects are up to date!');
+        }
+        else {
+            console.log(`⚠️  ${report.staleProjects.length} project(s) need updating:\n`);
+            for (const p of report.staleProjects) {
+                const icon = p.reason === 'git_activity' ? '📝' :
+                    p.reason === 'file_changed' ? '📄' : '⏰';
+                console.log(`  ${icon} ${p.name}`);
+                console.log(`     ${p.details}`);
+            }
+            console.log(`\n${report.freshCount} project(s) are fresh.`);
+            console.log('\nRun `claude-memory scan --quick` to refresh only stale projects.');
+        }
+        return;
+    }
     console.log('🧠 Claude Memory Scanner\n');
+    // Quick mode: only scan stale projects
+    let projectsToScan;
+    if (options.quick) {
+        const existingContext = loadContext();
+        if (existingContext) {
+            const report = detectStaleProjects(existingContext);
+            if (report.staleProjects.length === 0) {
+                console.log('✅ All projects are up to date! Nothing to scan.');
+                return;
+            }
+            projectsToScan = report.staleProjects.map(p => p.path);
+            console.log(`🔄 Quick mode: Rescanning ${projectsToScan.length} stale project(s)...\n`);
+        }
+    }
     const projects = await scanProjects({
         rootDir: directory,
         maxDepth: parseInt(options.depth, 10),
         generateClaudeMd: options.generateClaudeMd,
+        onlyPaths: projectsToScan,
     });
-    const context = generateGlobalContext(projects);
+    if (projects.length === 0) {
+        console.log('\n⚠️  No projects found. Context not updated.');
+        console.log('   Check the directory path and try again.');
+        return;
+    }
+    // For quick mode, merge with existing context
+    let context;
+    if (options.quick && projectsToScan) {
+        const existingContext = loadContext();
+        if (existingContext) {
+            // Replace only the rescanned projects
+            const rescannedPaths = new Set(projects.map(p => p.path));
+            const unchangedProjects = existingContext.projects.filter(p => !rescannedPaths.has(p.path));
+            context = {
+                ...existingContext,
+                lastUpdated: new Date().toISOString(),
+                projects: [...unchangedProjects, ...projects],
+            };
+        }
+        else {
+            context = generateGlobalContext(projects);
+        }
+    }
+    else {
+        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:');
@@ -89,6 +160,106 @@ program
     console.log(`  CLAUDE.md: ${project.hasFiles.claudeMd ? '✓' : '✗'}`);
     console.log(`  README.md: ${project.hasFiles.readme ? '✓' : '✗'}`);
 });
+// Exclude command - exclude a project from scanning
+program
+    .command('exclude')
+    .description('Exclude a project from future scans')
+    .argument('<project>', 'Project path or name')
+    .action((projectQuery) => {
+    const context = loadContext();
+    if (!context) {
+        console.log('No projects scanned yet. Run: claude-memory scan');
+        return;
+    }
+    // Find the project
+    const project = context.projects.find((p) => p.name.toLowerCase() === projectQuery.toLowerCase() || p.path.includes(projectQuery));
+    if (!project) {
+        // Maybe it's a direct path
+        if (existsSync(projectQuery)) {
+            addExclusion(projectQuery);
+            console.log(`✅ Excluded: ${projectQuery}`);
+            console.log('   This project will be skipped in future scans.');
+            return;
+        }
+        console.log(`Project not found: ${projectQuery}`);
+        return;
+    }
+    addExclusion(project.path);
+    console.log(`✅ Excluded: ${project.name}`);
+    console.log(`   Path: ${project.path}`);
+    console.log('   This project will be skipped in future scans.');
+    console.log('   Run `claude-memory include` to re-add it.');
+});
+// Include command - remove a project from exclusion list
+program
+    .command('include')
+    .description('Remove a project from the exclusion list')
+    .argument('<project>', 'Project path or name')
+    .action((projectQuery) => {
+    const context = loadContext();
+    if (!context) {
+        console.log('No projects scanned yet. Run: claude-memory scan');
+        return;
+    }
+    const excluded = context.excludedProjects || [];
+    const match = excluded.find(p => p.toLowerCase().includes(projectQuery.toLowerCase()));
+    if (!match) {
+        console.log(`Project not in exclusion list: ${projectQuery}`);
+        if (excluded.length > 0) {
+            console.log('\nCurrently excluded:');
+            excluded.forEach(p => console.log(`  - ${p}`));
+        }
+        return;
+    }
+    removeExclusion(match);
+    console.log(`✅ Removed from exclusion list: ${match}`);
+    console.log('   Run `claude-memory scan` to add it back to your projects.');
+});
+// Excluded command - list excluded projects
+program
+    .command('excluded')
+    .description('List excluded projects')
+    .action(() => {
+    const context = loadContext();
+    const excluded = context?.excludedProjects || [];
+    if (excluded.length === 0) {
+        console.log('No excluded projects.');
+        console.log('Use `claude-memory exclude <project>` to exclude a project.');
+        return;
+    }
+    console.log('🚫 Excluded Projects\n');
+    excluded.forEach(p => console.log(`  ${p}`));
+    console.log('\nUse `claude-memory include <project>` to re-add.');
+});
+function addExclusion(projectPath) {
+    const contextPath = join(getMemoryDir(), 'context.json');
+    if (!existsSync(contextPath))
+        return;
+    try {
+        const context = JSON.parse(readFileSync(contextPath, 'utf-8'));
+        context.excludedProjects = context.excludedProjects || [];
+        if (!context.excludedProjects.includes(projectPath)) {
+            context.excludedProjects.push(projectPath);
+            writeFileSync(contextPath, JSON.stringify(context, null, 2), 'utf-8');
+        }
+    }
+    catch {
+        console.error('Failed to update exclusion list');
+    }
+}
+function removeExclusion(projectPath) {
+    const contextPath = join(getMemoryDir(), 'context.json');
+    if (!existsSync(contextPath))
+        return;
+    try {
+        const context = JSON.parse(readFileSync(contextPath, 'utf-8'));
+        context.excludedProjects = (context.excludedProjects || []).filter((p) => p !== projectPath);
+        writeFileSync(contextPath, JSON.stringify(context, null, 2), 'utf-8');
+    }
+    catch {
+        console.error('Failed to update exclusion list');
+    }
+}
 // Briefing command - deep project analysis and CLAUDE.md generation
 program
     .command('briefing')
@@ -193,6 +364,68 @@ program
         interactive: !options.nonInteractive,
     });
 });
+// Activate command - activate a Pro license
+program
+    .command('activate')
+    .description('Activate a Pro license key')
+    .argument('<key>', 'License key (format: CM-XXXX-XXXX-XXXX)')
+    .action(async (key) => {
+    console.log('Activating license...\n');
+    const result = await activateLicense(key);
+    if (!result.valid) {
+        console.log(`❌ ${result.error}`);
+        return;
+    }
+    console.log('✅ License activated successfully!');
+    console.log(`   Plan: Pro`);
+    if (result.license?.email) {
+        console.log(`   Email: ${result.license.email}`);
+    }
+    console.log('\nPro features are now unlocked.');
+});
+// Status command - show license status
+program
+    .command('status')
+    .description('Show license status')
+    .action(() => {
+    const status = getLicenseStatus();
+    console.log('🧠 Claude Memory License Status\n');
+    console.log(`   Plan: ${status.plan === 'pro' ? 'Pro' : 'Free'}`);
+    if (status.isPro) {
+        if (status.email) {
+            console.log(`   Email: ${status.email}`);
+        }
+        if (status.activatedAt) {
+            console.log(`   Activated: ${new Date(status.activatedAt).toLocaleDateString()}`);
+        }
+        if (status.expiresAt) {
+            console.log(`   Expires: ${new Date(status.expiresAt).toLocaleDateString()}`);
+            if (status.daysRemaining) {
+                console.log(`   Days remaining: ${status.daysRemaining}`);
+            }
+        }
+        console.log(`   Status: Active`);
+    }
+    else {
+        console.log(`   Status: ${status.expiresAt ? 'Expired' : 'Not activated'}`);
+        console.log('\n   Upgrade at https://claude-memory.dev');
+        console.log('   Or run: claude-memory activate <your-key>');
+    }
+});
+// Deactivate command - remove license
+program
+    .command('deactivate')
+    .description('Remove Pro license')
+    .action(() => {
+    const removed = deactivateLicense();
+    if (removed) {
+        console.log('✅ License removed.');
+        console.log('   You are now on the Free plan.');
+    }
+    else {
+        console.log('No license to remove.');
+    }
+});
 function loadContext() {
     const contextPath = join(getMemoryDir(), 'context.json');
     if (!existsSync(contextPath)) {

package/dist/license/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * License management for Claude Memory Pro
+ */
+import { License, LicenseStatus, LicenseValidationResult } from './types.js';
+/**
+ * Load license from disk
+ */
+export declare function loadLicense(): License | null;
+/**
+ * Save license to disk
+ */
+export declare function saveLicense(license: License): void;
+/**
+ * Check if user has Pro license
+ */
+export declare function isPro(): boolean;
+/**
+ * Validate a license key format
+ */
+export declare function validateKeyFormat(key: string): boolean;
+/**
+ * Activate a license key
+ *
+ * Phase 1: Offline validation (format check only)
+ * Phase 2: Will call LemonSqueezy API for server validation
+ */
+export declare function activateLicense(key: string): Promise<LicenseValidationResult>;
+/**
+ * Deactivate (remove) the current license
+ */
+export declare function deactivateLicense(): boolean;
+/**
+ * Get current license status
+ */
+export declare function getLicenseStatus(): LicenseStatus;
+/**
+ * Get a user-friendly error message for Pro features
+ */
+export declare function getProFeatureMessage(featureName: string): string;

package/dist/license/index.js

@@ -0,0 +1,153 @@
+/**
+ * License management for Claude Memory Pro
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const MEMORY_DIR = join(homedir(), '.claude-memory');
+const LICENSE_PATH = join(MEMORY_DIR, 'license.json');
+// License key format: CM-XXXX-XXXX-XXXX (alphanumeric)
+const LICENSE_KEY_PATTERN = /^CM-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/i;
+/**
+ * Ensure the memory directory exists
+ */
+function ensureMemoryDir() {
+    if (!existsSync(MEMORY_DIR)) {
+        mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+}
+/**
+ * Load license from disk
+ */
+export function loadLicense() {
+    if (!existsSync(LICENSE_PATH)) {
+        return null;
+    }
+    try {
+        const data = readFileSync(LICENSE_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save license to disk
+ */
+export function saveLicense(license) {
+    ensureMemoryDir();
+    writeFileSync(LICENSE_PATH, JSON.stringify(license, null, 2), 'utf-8');
+}
+/**
+ * Check if user has Pro license
+ */
+export function isPro() {
+    const license = loadLicense();
+    if (!license) {
+        return false;
+    }
+    if (license.plan !== 'pro') {
+        return false;
+    }
+    // Check expiration
+    if (license.expiresAt) {
+        const expiresAt = new Date(license.expiresAt);
+        if (expiresAt < new Date()) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Validate a license key format
+ */
+export function validateKeyFormat(key) {
+    return LICENSE_KEY_PATTERN.test(key);
+}
+/**
+ * Activate a license key
+ *
+ * Phase 1: Offline validation (format check only)
+ * Phase 2: Will call LemonSqueezy API for server validation
+ */
+export async function activateLicense(key) {
+    // Normalize key to uppercase
+    const normalizedKey = key.toUpperCase();
+    // Validate format
+    if (!validateKeyFormat(normalizedKey)) {
+        return {
+            valid: false,
+            error: 'Invalid license key format. Expected: CM-XXXX-XXXX-XXXX',
+        };
+    }
+    // TODO: Phase 2 - Call LemonSqueezy API to validate
+    // const response = await fetch('https://api.claude-memory.dev/validate', {
+    //   method: 'POST',
+    //   body: JSON.stringify({ key: normalizedKey }),
+    // });
+    // For now, accept any valid format (Phase 1 - offline)
+    const license = {
+        key: normalizedKey,
+        plan: 'pro',
+        activatedAt: new Date().toISOString(),
+        // No expiration for now
+    };
+    saveLicense(license);
+    return {
+        valid: true,
+        license,
+    };
+}
+/**
+ * Deactivate (remove) the current license
+ */
+export function deactivateLicense() {
+    if (!existsSync(LICENSE_PATH)) {
+        return false;
+    }
+    try {
+        unlinkSync(LICENSE_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get current license status
+ */
+export function getLicenseStatus() {
+    const license = loadLicense();
+    if (!license) {
+        return {
+            isPro: false,
+            plan: 'free',
+        };
+    }
+    let daysRemaining;
+    let isExpired = false;
+    if (license.expiresAt) {
+        const expiresAt = new Date(license.expiresAt);
+        const now = new Date();
+        const diffMs = expiresAt.getTime() - now.getTime();
+        daysRemaining = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
+        isExpired = daysRemaining < 0;
+    }
+    return {
+        isPro: license.plan === 'pro' && !isExpired,
+        plan: isExpired ? 'free' : license.plan,
+        email: license.email,
+        expiresAt: license.expiresAt,
+        daysRemaining: daysRemaining && daysRemaining > 0 ? daysRemaining : undefined,
+        activatedAt: license.activatedAt,
+    };
+}
+/**
+ * Get a user-friendly error message for Pro features
+ */
+export function getProFeatureMessage(featureName) {
+    return `${featureName} is a Pro feature.
+
+Upgrade at https://claude-memory.dev or activate your license:
+  claude-memory activate <your-key>`;
+}

package/dist/license/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * License types for Claude Memory Pro
+ */
+export interface License {
+    /** License key (format: CM-XXXX-XXXX-XXXX) */
+    key: string;
+    /** Email associated with the license */
+    email?: string;
+    /** License plan */
+    plan: 'free' | 'pro';
+    /** When the license was activated */
+    activatedAt: string;
+    /** When the license expires (if applicable) */
+    expiresAt?: string;
+}
+export interface LicenseStatus {
+    /** Whether the user has Pro features */
+    isPro: boolean;
+    /** Current plan */
+    plan: 'free' | 'pro';
+    /** Email associated with license */
+    email?: string;
+    /** Expiration date */
+    expiresAt?: string;
+    /** Days remaining until expiration */
+    daysRemaining?: number;
+    /** When activated */
+    activatedAt?: string;
+}
+export interface LicenseValidationResult {
+    /** Whether the key is valid */
+    valid: boolean;
+    /** Error message if invalid */
+    error?: string;
+    /** License details if valid */
+    license?: License;
+}

package/dist/license/types.js

@@ -0,0 +1,4 @@
+/**
+ * License types for Claude Memory Pro
+ */
+export {};

package/dist/mcp/server.js

@@ -14,7 +14,10 @@ import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from '
 import { join } from 'path';
 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';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
+const CURRENT_VERSION = '0.2.3'; // Update this with each release
 // Tool definitions
 const tools = [
     {
@@ -92,6 +95,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');
@@ -218,6 +240,13 @@ function handleGetGlobalContext(cwd) {
         lines.push(`**Status:** ${cwdStatus.status}`);
         if (cwdStatus.projectName) {
             lines.push(`**Project:** ${cwdStatus.projectName}`);
+            // Check if current project is stale
+            if (context) {
+                const currentStaleness = checkCurrentProjectStaleness(context, cwd);
+                if (currentStaleness.isStale && currentStaleness.reason) {
+                    lines.push(`**⚠️ Stale:** ${currentStaleness.reason}`);
+                }
+            }
         }
         if (cwdStatus.needsSetup) {
             lines.push(`**Needs Setup:** Yes`);
@@ -243,9 +272,22 @@ function handleGetGlobalContext(cwd) {
         lines.push('No projects scanned yet. Run `claude-memory scan` first.');
         return lines.join('\n');
     }
+    // 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()}`);
+    lines.push(`Last scanned: ${new Date(context.lastUpdated).toLocaleString()} | claude-memory v${CURRENT_VERSION}`);
+    // Run detailed staleness check
+    const stalenessReport = detectStaleProjects(context);
+    // Add staleness warnings if needed
+    if (stalenessReport.staleProjects.length > 0) {
+        lines.push('');
+        lines.push(formatStalenessForMcp(stalenessReport));
+    }
+    else 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('');
@@ -344,6 +386,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) {
@@ -512,6 +583,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;
 /**