@contextmirror/claude-memory 0.2.0 → 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 {};