@contextmirror/claude-memory 0.2.1 → 0.2.2

package/dist/cli.js

@@ -16,6 +16,7 @@ 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';
 const program = new Command();
 program
     .name('claude-memory')
@@ -35,6 +36,11 @@ program
         maxDepth: parseInt(options.depth, 10),
         generateClaudeMd: options.generateClaudeMd,
     });
+    if (projects.length === 0) {
+        console.log('\n⚠️  No projects found. Context not updated.');
+        console.log('   Check the directory path and try again.');
+        return;
+    }
     const context = generateGlobalContext(projects);
     writeGlobalContext(context);
     console.log('\n✅ Done! Global context updated.');
@@ -89,6 +95,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 +299,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,6 +14,7 @@ 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';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
 // Tool definitions
 const tools = [
@@ -92,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');
@@ -243,9 +263,15 @@ 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()}`);
+    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 +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) {
@@ -512,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