@contextmirror/claude-memory 0.4.1 → 0.4.3

package/dist/cli.js

@@ -10,19 +10,26 @@
  */
 import { Command } from 'commander';
 import { readFileSync, existsSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 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';
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const VERSION = packageJson.version;
 const program = new Command();
 program
     .name('claude-memory')
     .description('Cross-project memory for Claude Code')
-    .version('0.1.0');
+    .version(VERSION);
 // Scan command
 program
     .command('scan')
@@ -37,7 +44,10 @@ program
     if (options.check) {
         const context = loadContext();
         if (!context) {
-            console.log('No projects scanned yet. Run: claude-memory scan');
+            console.log('❌ No projects scanned yet.\n');
+            console.log('Get started:');
+            console.log('  claude-memory setup           # Interactive wizard (recommended)');
+            console.log('  claude-memory scan ~/Projects # Scan a specific directory');
             return;
         }
         const report = detectStaleProjects(context);
@@ -119,7 +129,10 @@ program
     .action(() => {
     const context = loadContext();
     if (!context) {
-        console.log('No projects scanned yet. Run: claude-memory scan');
+        console.log('❌ No projects scanned yet.\n');
+        console.log('Get started:');
+        console.log('  claude-memory setup           # Interactive wizard (recommended)');
+        console.log('  claude-memory scan ~/Projects # Scan a specific directory');
         return;
     }
     console.log('🧠 Known Projects\n');
@@ -139,14 +152,27 @@ program
     .action((projectName) => {
     const context = loadContext();
     if (!context) {
-        console.log('No projects scanned yet. Run: claude-memory scan');
+        console.log('❌ No projects scanned yet.\n');
+        console.log('Get started:');
+        console.log('  claude-memory setup           # Interactive wizard (recommended)');
+        console.log('  claude-memory scan ~/Projects # Scan a specific directory');
         return;
     }
     const project = context.projects.find((p) => p.name.toLowerCase() === projectName.toLowerCase() || p.path.includes(projectName));
     if (!project) {
-        console.log(`Project not found: ${projectName}`);
-        console.log('\nKnown projects:');
-        context.projects.forEach((p) => console.log(`  - ${p.name}`));
+        console.log(`❌ Project not found: "${projectName}"\n`);
+        console.log('Did you mean one of these?\n');
+        // Show projects sorted by similarity to the query
+        const lowerQuery = projectName.toLowerCase();
+        const sorted = [...context.projects].sort((a, b) => {
+            const aScore = a.name.toLowerCase().includes(lowerQuery) ? 1 : 0;
+            const bScore = b.name.toLowerCase().includes(lowerQuery) ? 1 : 0;
+            return bScore - aScore;
+        });
+        sorted.slice(0, 5).forEach((p) => console.log(`  ${p.name}  (${p.path})`));
+        if (context.projects.length > 5) {
+            console.log(`\n  ... and ${context.projects.length - 5} more. Run 'claude-memory list' to see all.`);
+        }
         return;
     }
     console.log(`\n📁 ${project.name}\n`);
@@ -168,7 +194,10 @@ program
     .action((projectQuery) => {
     const context = loadContext();
     if (!context) {
-        console.log('No projects scanned yet. Run: claude-memory scan');
+        console.log('❌ No projects scanned yet.\n');
+        console.log('Get started:');
+        console.log('  claude-memory setup           # Interactive wizard (recommended)');
+        console.log('  claude-memory scan ~/Projects # Scan a specific directory');
         return;
     }
     // Find the project
@@ -181,7 +210,8 @@ program
             console.log('   This project will be skipped in future scans.');
             return;
         }
-        console.log(`Project not found: ${projectQuery}`);
+        console.log(`❌ Project not found: "${projectQuery}"\n`);
+        console.log('Tip: Use the project name or path. Run "claude-memory list" to see all projects.');
         return;
     }
     addExclusion(project.path);
@@ -198,16 +228,23 @@ program
     .action((projectQuery) => {
     const context = loadContext();
     if (!context) {
-        console.log('No projects scanned yet. Run: claude-memory scan');
+        console.log('❌ No projects scanned yet.\n');
+        console.log('Get started:');
+        console.log('  claude-memory setup           # Interactive wizard (recommended)');
+        console.log('  claude-memory scan ~/Projects # Scan a specific directory');
         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}`);
+        console.log(`❌ Project not in exclusion list: "${projectQuery}"\n`);
         if (excluded.length > 0) {
-            console.log('\nCurrently excluded:');
-            excluded.forEach(p => console.log(`  - ${p}`));
+            console.log('Currently excluded:');
+            excluded.forEach(p => console.log(`  ${p}`));
+            console.log('\nRun "claude-memory excluded" to see all excluded projects.');
+        }
+        else {
+            console.log('No projects are currently excluded.');
         }
         return;
     }

package/dist/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized constants for Claude Memory
+ */
+export declare const GIT_TIMEOUT_MS = 10000;
+export declare const UPDATE_CHECK_INTERVAL_MS: number;
+export declare const STALE_DATA_HOURS = 24;
+export declare const STALE_PROJECT_DAYS = 7;
+export declare const MAX_README_CHARS = 3000;
+export declare const MAX_DESCRIPTION_CHARS = 200;
+export declare const PRODUCT_URL = "https://claude-memory.dev";
+export declare const DISCORD_URL = "https://discord.gg/JBpsSFB7EQ";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/@contextmirror/claude-memory";
+export declare const LEMONSQUEEZY_VALIDATE_URL = "https://api.lemonsqueezy.com/v1/licenses/validate";
+export declare const MEMORY_DIR_NAME = ".claude-memory";
+export declare const CONTEXT_FILE = "context.json";
+export declare const CONTEXT_BACKUP_FILE = "context.json.bak";
+export declare const CONFIG_FILE = "config.json";
+export declare const LICENSE_FILE = "license.json";
+export declare const UPDATE_CACHE_FILE = "update-check.json";
+export declare const GLOBAL_CONTEXT_MD = "global-context.md";
+export declare const PROJECT_MARKERS: string[];
+export declare const IGNORE_DIRS: string[];
+export declare const EXIT_SUCCESS = 0;
+export declare const EXIT_ERROR = 1;
+export declare const EXIT_INVALID_ARGS = 2;

package/dist/constants.js

@@ -0,0 +1,53 @@
+/**
+ * Centralized constants for Claude Memory
+ */
+// Timeouts
+export const GIT_TIMEOUT_MS = 10000;
+export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+// Staleness thresholds
+export const STALE_DATA_HOURS = 24;
+export const STALE_PROJECT_DAYS = 7;
+// File limits
+export const MAX_README_CHARS = 3000;
+export const MAX_DESCRIPTION_CHARS = 200;
+// URLs
+export const PRODUCT_URL = 'https://claude-memory.dev';
+export const DISCORD_URL = 'https://discord.gg/JBpsSFB7EQ';
+export const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@contextmirror/claude-memory';
+export const LEMONSQUEEZY_VALIDATE_URL = 'https://api.lemonsqueezy.com/v1/licenses/validate';
+// Paths
+export const MEMORY_DIR_NAME = '.claude-memory';
+export const CONTEXT_FILE = 'context.json';
+export const CONTEXT_BACKUP_FILE = 'context.json.bak';
+export const CONFIG_FILE = 'config.json';
+export const LICENSE_FILE = 'license.json';
+export const UPDATE_CACHE_FILE = 'update-check.json';
+export const GLOBAL_CONTEXT_MD = 'global-context.md';
+// Project detection patterns
+export const PROJECT_MARKERS = [
+    'package.json',
+    'Cargo.toml',
+    'pyproject.toml',
+    'go.mod',
+    '.git',
+    'requirements.txt',
+];
+// Directories to ignore during scanning
+export const IGNORE_DIRS = [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '__pycache__',
+    'target',
+    '.venv',
+    'venv',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.cache',
+];
+// Exit codes
+export const EXIT_SUCCESS = 0;
+export const EXIT_ERROR = 1;
+export const EXIT_INVALID_ARGS = 2;

package/dist/license/index.d.ts

@@ -15,14 +15,18 @@ export declare function saveLicense(license: License): void;
  */
 export declare function isPro(): boolean;
 /**
- * Validate a license key format
+ * Check if key is LemonSqueezy format
+ */
+export declare function isLemonSqueezyKey(key: string): boolean;
+/**
+ * Validate a license key format (accepts both LemonSqueezy and legacy formats)
  */
 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
+ * For LemonSqueezy keys: Validates against their API
+ * For legacy keys: Format check only (backwards compatibility)
  */
 export declare function activateLicense(key: string): Promise<LicenseValidationResult>;
 /**

package/dist/license/index.js

@@ -4,10 +4,14 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { LEMONSQUEEZY_VALIDATE_URL } from '../constants.js';
 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;
+// License key formats:
+// - LemonSqueezy: UUID format (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+// - Legacy: CM-XXXX-XXXX-XXXX (alphanumeric)
+const LEMONSQUEEZY_KEY_PATTERN = /^[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}$/i;
+const LEGACY_KEY_PATTERN = /^CM-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/i;
 /**
  * Ensure the memory directory exists
  */
@@ -59,38 +63,92 @@ export function isPro() {
     return true;
 }
 /**
- * Validate a license key format
+ * Check if key is LemonSqueezy format
+ */
+export function isLemonSqueezyKey(key) {
+    return LEMONSQUEEZY_KEY_PATTERN.test(key);
+}
+/**
+ * Validate a license key format (accepts both LemonSqueezy and legacy formats)
  */
 export function validateKeyFormat(key) {
-    return LICENSE_KEY_PATTERN.test(key);
+    return LEMONSQUEEZY_KEY_PATTERN.test(key) || LEGACY_KEY_PATTERN.test(key);
+}
+/**
+ * Validate license key with LemonSqueezy API
+ */
+async function validateWithLemonSqueezy(key) {
+    try {
+        const response = await fetch(LEMONSQUEEZY_VALIDATE_URL, {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                license_key: key,
+            }),
+        });
+        const data = await response.json();
+        if (data.valid) {
+            return {
+                valid: true,
+                email: data.meta?.customer_email,
+            };
+        }
+        else {
+            return {
+                valid: false,
+                error: data.error || 'License key is not valid',
+            };
+        }
+    }
+    catch (err) {
+        // Network error - allow offline activation with warning
+        return {
+            valid: true, // Allow offline - will revalidate later
+            error: 'Could not reach license server. Activating offline.',
+        };
+    }
 }
 /**
  * Activate a license key
  *
- * Phase 1: Offline validation (format check only)
- * Phase 2: Will call LemonSqueezy API for server validation
+ * For LemonSqueezy keys: Validates against their API
+ * For legacy keys: Format check only (backwards compatibility)
  */
 export async function activateLicense(key) {
-    // Normalize key to uppercase
+    // Normalize key (LemonSqueezy keys are uppercase hex)
     const normalizedKey = key.toUpperCase();
     // Validate format
     if (!validateKeyFormat(normalizedKey)) {
         return {
             valid: false,
-            error: 'Invalid license key format. Expected: CM-XXXX-XXXX-XXXX',
+            error: 'Invalid license key format. Get your key from https://claude-memory.dev',
         };
     }
-    // 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)
+    let email;
+    // Validate LemonSqueezy keys with their API
+    if (isLemonSqueezyKey(normalizedKey)) {
+        const result = await validateWithLemonSqueezy(normalizedKey);
+        if (!result.valid) {
+            return {
+                valid: false,
+                error: result.error || 'License validation failed',
+            };
+        }
+        email = result.email;
+        // Show offline warning if applicable
+        if (result.error) {
+            console.log(`⚠️  ${result.error}`);
+        }
+    }
     const license = {
         key: normalizedKey,
         plan: 'pro',
         activatedAt: new Date().toISOString(),
-        // No expiration for now
+        email,
+        // Subscription licenses don't expire locally - LemonSqueezy handles this
     };
     saveLicense(license);
     return {

package/dist/mcp/server.js

@@ -11,14 +11,21 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { readFileSync, existsSync, readdirSync, statSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import { homedir } from 'os';
+import { fileURLToPath } from 'url';
 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';
+import { searchCode, formatSearchResults } from '../utils/codeSearch.js';
 const MEMORY_DIR = join(homedir(), '.claude-memory');
-const CURRENT_VERSION = '0.4.0'; // Update this with each release
+// Read version from package.json to ensure single source of truth
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const CURRENT_VERSION = packageJson.version;
 // Tool definitions
 const tools = [
     {
@@ -405,22 +412,22 @@ function handleSearchCode(query, filePattern) {
     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})`);
+    if (!query || query.trim().length === 0) {
+        return 'Please provide a search query.';
     }
-    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');
+    // Map projects to the format expected by searchCode
+    const projects = context.projects.map(p => ({
+        name: p.name,
+        path: p.path,
+    }));
+    // Perform the search
+    const results = searchCode(projects, query, {
+        filePattern,
+        maxResults: 50,
+        caseSensitive: false,
+        contextLines: 1,
+    });
+    return formatSearchResults(results, query);
 }
 function handleGetProjectAnalysis(projectQuery) {
     const context = loadContext();
@@ -559,7 +566,7 @@ function getDirectoryStructure(dir, maxDepth, prefix = '', depth = 0) {
 async function main() {
     const server = new Server({
         name: 'claude-memory',
-        version: '0.1.0',
+        version: CURRENT_VERSION,
     }, {
         capabilities: {
             tools: {},

package/dist/utils/codeSearch.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Code search utility for Pro feature
+ */
+export interface SearchResult {
+    project: string;
+    projectPath: string;
+    file: string;
+    relativePath: string;
+    line: number;
+    content: string;
+    context: {
+        before: string;
+        after: string;
+    };
+}
+export interface SearchOptions {
+    filePattern?: string;
+    maxResults?: number;
+    caseSensitive?: boolean;
+    contextLines?: number;
+}
+/**
+ * Search for code across multiple projects
+ */
+export declare function searchCode(projects: Array<{
+    name: string;
+    path: string;
+}>, query: string, options?: SearchOptions): SearchResult[];
+/**
+ * Format search results for display
+ */
+export declare function formatSearchResults(results: SearchResult[], query: string): string;

package/dist/utils/codeSearch.js

@@ -0,0 +1,187 @@
+/**
+ * Code search utility for Pro feature
+ */
+import { readdirSync, readFileSync, statSync } from 'fs';
+import { join, extname, relative } from 'path';
+import { IGNORE_DIRS } from '../constants.js';
+const DEFAULT_OPTIONS = {
+    maxResults: 50,
+    caseSensitive: false,
+    contextLines: 1,
+};
+// File extensions to search
+const SEARCHABLE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.pyw',
+    '.rs',
+    '.go',
+    '.java', '.kt', '.scala',
+    '.c', '.cpp', '.h', '.hpp',
+    '.rb',
+    '.php',
+    '.swift',
+    '.cs',
+    '.vue', '.svelte',
+    '.json', '.yaml', '.yml', '.toml',
+    '.md', '.txt',
+    '.sql',
+    '.sh', '.bash', '.zsh',
+    '.css', '.scss', '.sass', '.less',
+    '.html', '.htm',
+    '.xml',
+]);
+// Max file size to search (1MB)
+const MAX_FILE_SIZE = 1024 * 1024;
+/**
+ * Check if a file should be searched based on extension
+ */
+function shouldSearchFile(filePath, filePattern) {
+    const ext = extname(filePath).toLowerCase();
+    // If a pattern is specified, use glob-like matching
+    if (filePattern) {
+        if (filePattern.startsWith('*.')) {
+            const patternExt = filePattern.slice(1);
+            return ext === patternExt;
+        }
+        return filePath.includes(filePattern);
+    }
+    return SEARCHABLE_EXTENSIONS.has(ext);
+}
+/**
+ * Search for a pattern in a file
+ */
+function searchFile(filePath, query, options) {
+    const results = [];
+    try {
+        const stat = statSync(filePath);
+        if (stat.size > MAX_FILE_SIZE) {
+            return results;
+        }
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const searchQuery = options.caseSensitive ? query : query.toLowerCase();
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const searchLine = options.caseSensitive ? line : line.toLowerCase();
+            if (searchLine.includes(searchQuery)) {
+                const contextLines = options.contextLines || 1;
+                const beforeLines = lines.slice(Math.max(0, i - contextLines), i);
+                const afterLines = lines.slice(i + 1, Math.min(lines.length, i + 1 + contextLines));
+                results.push({
+                    line: i + 1,
+                    content: line.trim(),
+                    context: {
+                        before: beforeLines.join('\n'),
+                        after: afterLines.join('\n'),
+                    },
+                });
+            }
+        }
+    }
+    catch {
+        // Skip files that can't be read
+    }
+    return results;
+}
+/**
+ * Recursively search a directory
+ */
+function searchDirectory(dir, query, projectName, projectPath, options, results) {
+    if (results.length >= (options.maxResults || DEFAULT_OPTIONS.maxResults)) {
+        return;
+    }
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            if (results.length >= (options.maxResults || DEFAULT_OPTIONS.maxResults)) {
+                return;
+            }
+            if (IGNORE_DIRS.includes(entry) || entry.startsWith('.')) {
+                continue;
+            }
+            const fullPath = join(dir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    searchDirectory(fullPath, query, projectName, projectPath, options, results);
+                }
+                else if (stat.isFile() && shouldSearchFile(fullPath, options.filePattern)) {
+                    const fileResults = searchFile(fullPath, query, options);
+                    for (const result of fileResults) {
+                        if (results.length >= (options.maxResults || DEFAULT_OPTIONS.maxResults)) {
+                            return;
+                        }
+                        results.push({
+                            project: projectName,
+                            projectPath,
+                            file: fullPath,
+                            relativePath: relative(projectPath, fullPath),
+                            line: result.line,
+                            content: result.content,
+                            context: result.context,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip inaccessible files
+            }
+        }
+    }
+    catch {
+        // Skip inaccessible directories
+    }
+}
+/**
+ * Search for code across multiple projects
+ */
+export function searchCode(projects, query, options = {}) {
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const results = [];
+    for (const project of projects) {
+        if (results.length >= mergedOptions.maxResults) {
+            break;
+        }
+        searchDirectory(project.path, query, project.name, project.path, mergedOptions, results);
+    }
+    return results;
+}
+/**
+ * Format search results for display
+ */
+export function formatSearchResults(results, query) {
+    if (results.length === 0) {
+        return `No results found for "${query}".`;
+    }
+    const lines = [
+        `# Code Search Results for "${query}"`,
+        '',
+        `Found ${results.length} result${results.length === 1 ? '' : 's'}:`,
+        '',
+    ];
+    // Group by project
+    const byProject = new Map();
+    for (const result of results) {
+        const existing = byProject.get(result.project) || [];
+        existing.push(result);
+        byProject.set(result.project, existing);
+    }
+    for (const [project, projectResults] of byProject) {
+        lines.push(`## ${project}`);
+        lines.push('');
+        for (const result of projectResults) {
+            lines.push(`### ${result.relativePath}:${result.line}`);
+            lines.push('```');
+            if (result.context.before) {
+                lines.push(result.context.before);
+            }
+            lines.push(`> ${result.content}`);
+            if (result.context.after) {
+                lines.push(result.context.after);
+            }
+            lines.push('```');
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}