claude-mem 3.0.2 → 3.0.4

package/dist/commands/load-context.js

@@ -0,0 +1,330 @@
+import { getMCPClient } from '../utils/mcp-client.js';
+import { SESSION_START_TEMPLATES, TIME_FORMATS, CLI_MESSAGES, CONTEXT_TEMPLATES } from '../constants.js';
+// =============================================================================
+// HELPER FUNCTIONS FOR WEAVIATE INTEGRATION
+// =============================================================================
+/**
+ * Build search query based on CLI options
+ * @param options CLI options from commander
+ * @returns Search query string for Weaviate
+ */
+function buildSearchQuery(options) {
+    // If project is specified, search for entities with that project prefix
+    if (options.project) {
+        return `${options.project}_`;
+    }
+    // Default to searching for all entities (return empty string for broad search)
+    return '';
+}
+/**
+ * Format Weaviate search results for display
+ * @param result MCPSearchResult from Weaviate
+ * @param options CLI options for formatting
+ * @returns Formatted display data
+ */
+function formatWeaviateResults(result, options) {
+    const entities = result.entities || [];
+    if (entities.length === 0) {
+        return {
+            entries: [],
+            isEmpty: true
+        };
+    }
+    // Convert entities to the format expected by existing formatting functions
+    const entries = entities.map(entity => ({
+        summary: entity.observations?.[0] || entity.name.replace(/^[^_]+_/, ''),
+        nodes: [entity.name],
+        keywords: extractKeywordsFromEntity(entity),
+        timestamp: new Date().toISOString(), // Use current time as fallback
+        project: extractProjectFromEntityName(entity.name)
+    }));
+    // Apply count limit
+    const count = parseInt(options.count) || 10;
+    const limitedEntries = entries.slice(-count);
+    return {
+        entries: limitedEntries,
+        isEmpty: false
+    };
+}
+/**
+ * Extract keywords from entity observations
+ * @param entity MCPEntity
+ * @returns Array of keywords
+ */
+function extractKeywordsFromEntity(entity) {
+    const keywords = [];
+    // Add entity type as keyword
+    if (entity.entityType) {
+        keywords.push(entity.entityType);
+    }
+    // Extract keywords from observations (simple word extraction)
+    if (entity.observations) {
+        entity.observations.forEach(obs => {
+            const words = obs.split(/\s+/).filter(word => word.length > 3);
+            keywords.push(...words.slice(0, 3)); // Take first 3 meaningful words
+        });
+    }
+    return [...new Set(keywords)]; // Remove duplicates
+}
+/**
+ * Extract project name from entity name
+ * @param entityName Full entity name
+ * @returns Project name
+ */
+function extractProjectFromEntityName(entityName) {
+    const parts = entityName.split('_');
+    return parts[0] || 'unknown';
+}
+function extractEntityType(nodes, types) {
+    const results = [];
+    for (const node of nodes) {
+        for (const type of types) {
+            if (node.toLowerCase().includes(type.toLowerCase())) {
+                results.push(node);
+                break;
+            }
+        }
+    }
+    return [...new Set(results)];
+}
+function formatEntityList(entities, entries) {
+    let output = '';
+    const seen = new Set();
+    entities.forEach(entity => {
+        if (!seen.has(entity)) {
+            seen.add(entity);
+            const cleanName = entity.replace(/^[^_]+_/, '');
+            const summary = findEntitySummary(entity, entries);
+            output += `${SESSION_START_TEMPLATES.ENTITY_BULLET}${cleanName}`;
+            if (summary) {
+                output += ` - ${summary}`;
+            }
+            output += '\n';
+        }
+    });
+    return output;
+}
+function findEntitySummary(entity, entries) {
+    for (const entry of entries) {
+        if (entry.nodes && entry.nodes.includes(entity)) {
+            return entry.summary || '';
+        }
+    }
+    return '';
+}
+function extractFocus(entries) {
+    const recent = entries[entries.length - 1];
+    if (recent.summary) {
+        return recent.summary;
+    }
+    const keywords = entries.flatMap(e => e.keywords || []);
+    const allKeywords = getMostFrequent(keywords);
+    return allKeywords.join(', ') || 'General development';
+}
+function extractNextActions(entries) {
+    const actions = [];
+    for (const entry of entries) {
+        if (entry.summary) {
+            if (entry.summary.toLowerCase().includes('todo') ||
+                entry.summary.toLowerCase().includes('next')) {
+                actions.push(entry.summary);
+            }
+            else if (entry.summary.toLowerCase().includes('implement')) {
+                actions.push(`Continue: ${entry.summary}`);
+            }
+        }
+    }
+    if (actions.length === 0 && entries.length > 0) {
+        const recent = entries[entries.length - 1];
+        if (recent.keywords && recent.keywords.length > 0) {
+            actions.push(`Review and continue work on: ${recent.keywords.join(', ')}`);
+        }
+    }
+    return actions;
+}
+function getMostFrequent(items, count) {
+    const frequency = new Map();
+    items.forEach(item => {
+        frequency.set(item, (frequency.get(item) || 0) + 1);
+    });
+    const sorted = Array.from(frequency.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([item]) => item);
+    return count ? sorted.slice(0, count) : sorted;
+}
+function timeAgo(timestamp) {
+    if (!timestamp)
+        return TIME_FORMATS.RECENTLY;
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffHours < 1) {
+        return TIME_FORMATS.JUST_NOW;
+    }
+    else if (diffHours < 24) {
+        return TIME_FORMATS.HOURS_AGO(diffHours);
+    }
+    else if (diffDays < 7) {
+        return TIME_FORMATS.DAYS_AGO(diffDays);
+    }
+    else {
+        return date.toLocaleDateString();
+    }
+}
+function formatSessionStart(entries) {
+    if (entries.length === 0) {
+        return ''; // Return empty string for session-start format
+    }
+    const recent = entries[entries.length - 1];
+    const allNodes = entries.flatMap(e => e.nodes || []);
+    const projectName = recent.project || 'Unknown Project';
+    const components = extractEntityType(allNodes, ['Component', 'Service', 'Module', 'Class']);
+    const decisions = extractEntityType(allNodes, ['Decision', 'Choice', 'Strategy']);
+    const patterns = extractEntityType(allNodes, ['Pattern', 'Architecture', 'Workflow']);
+    const tools = extractEntityType(allNodes, ['Tool', 'Library', 'Integration']);
+    const fixes = extractEntityType(allNodes, ['Fix', 'Bug', 'Issue']);
+    let output = CONTEXT_TEMPLATES.SESSION_START_HEADER + '\n';
+    output += CONTEXT_TEMPLATES.SESSION_START_SEPARATOR + '\n\n';
+    output += SESSION_START_TEMPLATES.FOCUS_LINE(extractFocus(entries)) + '\n';
+    output += SESSION_START_TEMPLATES.LAST_WORKED(timeAgo(recent.timestamp), projectName) + '\n\n';
+    if (components.length > 0) {
+        output += SESSION_START_TEMPLATES.SECTIONS.COMPONENTS + '\n';
+        output += formatEntityList(components, entries);
+        output += '\n';
+    }
+    if (decisions.length > 0 || patterns.length > 0) {
+        output += SESSION_START_TEMPLATES.SECTIONS.DECISIONS + '\n';
+        output += formatEntityList([...decisions, ...patterns], entries);
+        output += '\n';
+    }
+    if (tools.length > 0) {
+        output += SESSION_START_TEMPLATES.SECTIONS.TOOLS + '\n';
+        output += formatEntityList(tools, entries);
+        output += '\n';
+    }
+    if (fixes.length > 0) {
+        output += SESSION_START_TEMPLATES.SECTIONS.FIXES + '\n';
+        output += formatEntityList(fixes, entries);
+        output += '\n';
+    }
+    const nextActions = extractNextActions(entries);
+    if (nextActions.length > 0) {
+        output += SESSION_START_TEMPLATES.SECTIONS.ACTIONS + '\n';
+        nextActions.forEach(action => {
+            output += `${SESSION_START_TEMPLATES.ACTION_PREFIX}${action}\n`;
+        });
+        output += '\n';
+    }
+    output += CONTEXT_TEMPLATES.RESUME_INSTRUCTIONS + '\n\n';
+    output += CONTEXT_TEMPLATES.SESSION_START_SEPARATOR;
+    return output;
+}
+export async function loadContext(options = {}) {
+    try {
+        // Get MCP client connected to embedded Weaviate
+        const client = await getMCPClient();
+        await client.connect();
+        // Build search query based on options
+        const searchQuery = buildSearchQuery(options);
+        // Execute search in embedded Weaviate
+        let searchResult;
+        if (searchQuery) {
+            searchResult = await client.searchNodes(searchQuery);
+        }
+        else {
+            // For broad search, search for common entity patterns
+            searchResult = await client.searchNodes('Component_ Decision_ Pattern_ Tool_ Fix_');
+        }
+        // Format results for display
+        const { entries, isEmpty } = formatWeaviateResults(searchResult, options);
+        if (isEmpty) {
+            if (options.format === 'session-start') {
+                // For session-start format, output nothing when no memories exist
+                return;
+            }
+            console.log(CLI_MESSAGES.STATUS.NO_MATCHES);
+            return;
+        }
+        // Sort entries by timestamp from oldest to newest
+        entries.sort((a, b) => {
+            const timeA = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+            const timeB = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+            return timeA - timeB;
+        });
+        const count = parseInt(options.count) || 10;
+        const recentEntries = entries.slice(-count);
+        // Output in requested format
+        if (options.raw || options.format === 'json') {
+            recentEntries.forEach(entry => {
+                console.log(JSON.stringify(entry));
+            });
+        }
+        else if (options.format === 'session-start') {
+            console.log(formatSessionStart(recentEntries));
+        }
+        else {
+            // Default interactive format
+            console.log(CLI_MESSAGES.STATUS.RECENT_MEMORIES);
+            console.log('═'.repeat(70));
+            recentEntries.forEach((entry, index) => {
+                console.log(`\n${index + 1}. ${entry.summary}`);
+                if (entry.nodes && entry.nodes.length > 0) {
+                    const nodeNames = entry.nodes
+                        .map((n) => n.replace(/^[^_]+_/, ''))
+                        .join(' • ');
+                    console.log(`   📍 ${nodeNames}`);
+                }
+                if (entry.keywords && entry.keywords.length > 0) {
+                    console.log(`   🔖 ${entry.keywords.join(', ')}`);
+                }
+                if (entry.timestamp) {
+                    const date = new Date(entry.timestamp);
+                    const now = new Date();
+                    const diffMs = now.getTime() - date.getTime();
+                    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+                    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+                    let timeStr;
+                    if (diffHours < 1) {
+                        timeStr = 'just now';
+                    }
+                    else if (diffHours < 24) {
+                        timeStr = `${diffHours} hour${diffHours > 1 ? 's' : ''} ago`;
+                    }
+                    else if (diffDays < 7) {
+                        timeStr = `${diffDays} day${diffDays > 1 ? 's' : ''} ago`;
+                    }
+                    else {
+                        timeStr = date.toLocaleDateString();
+                    }
+                    console.log(`   ⏰ ${timeStr}`);
+                }
+            });
+            console.log('\n' + '═'.repeat(70));
+            console.log(CLI_MESSAGES.STATUS.MEMORY_COUNT(recentEntries.length));
+            console.log(CLI_MESSAGES.STATUS.FULL_CONTEXT_AVAILABLE);
+        }
+    }
+    catch (error) {
+        // Enhanced error handling for Weaviate connection failures
+        if (error instanceof Error) {
+            if (error.message.includes('connection') || error.message.includes('ECONNREFUSED')) {
+                console.error('❌ Failed to connect to embedded Weaviate instance.');
+                console.error('   Try running: claude-mem install --force');
+                console.error('   Or check: claude-mem status');
+            }
+            else if (error.message.includes('schema') || error.message.includes('collection')) {
+                console.error('❌ Weaviate schema not initialized.');
+                console.error('   Try running: claude-mem install --force');
+            }
+            else {
+                console.error(CLI_MESSAGES.ERRORS.CONTEXT_LOAD_FAILED(error.message));
+            }
+        }
+        else {
+            console.error(CLI_MESSAGES.ERRORS.CONTEXT_LOAD_FAILED(String(error)));
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,2 @@
+import { OptionValues } from 'commander';
+export declare function logs(options?: OptionValues): Promise<void>;

package/dist/commands/logs.js

@@ -0,0 +1,41 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+async function showLog(logPath, logType, tail) {
+    try {
+        const content = readFileSync(logPath, 'utf8');
+        const lines = content.split('\n').filter(line => line.trim());
+        const displayLines = lines.slice(-tail);
+        console.log(`📋 ${logType} Logs (last ${tail} lines):`);
+        console.log(`   File: ${logPath}`);
+        console.log('');
+        if (displayLines.length === 0) {
+            console.log('   No log entries found');
+        }
+        else {
+            displayLines.forEach(line => {
+                console.log(`   ${line}`);
+            });
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.log(`❌ Could not read ${logType.toLowerCase()} log: ${logPath}`);
+    }
+}
+export async function logs(options = {}) {
+    const logsDir = join(process.cwd(), 'logs');
+    const tail = parseInt(options.tail) || 20;
+    if (options.error || (!options.debug && !options.error)) {
+        await showLog(join(logsDir, 'claude-mem-error.log'), 'Error', tail);
+    }
+    if (options.debug) {
+        await showLog(join(logsDir, 'claude-mem-debug.log'), 'Debug', tail);
+    }
+    if (options.follow) {
+        console.log('Following logs... (Press Ctrl+C to stop)');
+        // Basic follow implementation - would need more sophisticated watching in real usage
+        setInterval(() => {
+            // This would need proper file watching implementation
+        }, 1000);
+    }
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,9 @@
+import { OptionValues } from 'commander';
+interface MigrationOptions extends OptionValues {
+    from?: 'memory' | 'weaviate';
+    to?: 'memory' | 'weaviate';
+    dryRun?: boolean;
+    force?: boolean;
+}
+export declare function migrate(options?: MigrationOptions): Promise<void>;
+export {};

package/dist/commands/migrate.js

@@ -0,0 +1,174 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * Simple MCP client interface for migration purposes
+ * This is a minimal implementation to avoid complex dependencies
+ */
+class MigrationMCPClient {
+    backend;
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async connect() {
+        console.log(`🔗 Connecting to ${this.backend} backend...`);
+        // In a real implementation, this would establish the connection
+        // For now, we'll simulate the connection
+    }
+    async disconnect() {
+        console.log(`👋 Disconnected from ${this.backend} backend`);
+    }
+    async createEntities(entities) {
+        console.log(`📝 Creating ${entities.length} entities in ${this.backend} backend...`);
+        // In a real implementation, this would call the appropriate MCP server
+        // For migration purposes, we simulate the creation
+        entities.forEach(entity => {
+            console.log(`  • Created entity: ${entity.name}`);
+        });
+    }
+    async createRelations(relations) {
+        console.log(`🔗 Creating ${relations.length} relations in ${this.backend} backend...`);
+        // In a real implementation, this would call the appropriate MCP server
+        relations.forEach(relation => {
+            console.log(`  • Created relation: ${relation.from} -> ${relation.to}`);
+        });
+    }
+    async getAllEntities() {
+        console.log(`📖 Reading all entities from ${this.backend} backend...`);
+        // In a real implementation, this would query the MCP server for all entities
+        // For migration, we'll need to implement this based on the source backend
+        return [];
+    }
+    async getAllRelations() {
+        console.log(`🔗 Reading all relations from ${this.backend} backend...`);
+        // In a real implementation, this would query the MCP server for all relations
+        return [];
+    }
+}
+function loadUserSettings() {
+    const settingsPath = join(homedir(), '.claude-mem', 'settings.json');
+    if (!existsSync(settingsPath)) {
+        return { backend: 'memory' };
+    }
+    try {
+        const content = readFileSync(settingsPath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.log(`⚠️  Could not parse settings file: ${error.message}`);
+        return { backend: 'memory' };
+    }
+}
+function saveUserSettings(settings) {
+    const settingsPath = join(homedir(), '.claude-mem', 'settings.json');
+    try {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log(`✅ Updated settings with new backend: ${settings.backend}`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to save settings: ${error.message}`);
+    }
+}
+function readIndexFiles() {
+    const indexDir = join(homedir(), '.claude-mem', 'index');
+    const archivesDir = join(homedir(), '.claude-mem', 'archives');
+    const entities = [];
+    const relations = [];
+    const entries = [];
+    if (!existsSync(indexDir)) {
+        console.log('📂 No index directory found');
+        return { entities, relations, entries };
+    }
+    try {
+        const indexFiles = readdirSync(indexDir).filter(file => file.endsWith('.jsonl'));
+        for (const file of indexFiles) {
+            const filePath = join(indexDir, file);
+            const content = readFileSync(filePath, 'utf8');
+            const lines = content.trim().split('\n').filter(line => line.trim());
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    entries.push(entry);
+                    // Extract entities and relations from the index entry's nodes
+                    // In a real migration, we'd need to query the source MCP server
+                    // For now, we'll create basic entities from the node names
+                    if (entry.nodes && Array.isArray(entry.nodes)) {
+                        entry.nodes.forEach(nodeName => {
+                            // Extract entity type from node name (e.g., "project_Component_Name")
+                            const parts = nodeName.split('_');
+                            if (parts.length >= 3) {
+                                const entityType = parts[1].toLowerCase();
+                                const entity = {
+                                    name: nodeName,
+                                    entityType: entityType,
+                                    observations: [
+                                        `Core purpose: ${entry.summary}`,
+                                        `Brief description: ${entry.summary}`,
+                                        `Session: ${entry.session_id}`,
+                                        `Project: ${entry.project}`,
+                                        `Keywords: ${entry.keywords?.join(', ') || ''}`,
+                                        `UUID: ${entry.uuid}`
+                                    ]
+                                };
+                                entities.push(entity);
+                                // Create a relation to the session entity
+                                const sessionEntityName = `${entry.project}_Session_${entry.session_id}`;
+                                const relation = {
+                                    from: sessionEntityName,
+                                    to: nodeName,
+                                    relationType: 'contains'
+                                };
+                                relations.push(relation);
+                            }
+                        });
+                    }
+                }
+                catch (error) {
+                    console.log(`⚠️  Skipping malformed index entry: ${error.message}`);
+                }
+            }
+        }
+        console.log(`📊 Found ${entries.length} index entries, extracted ${entities.length} entities and ${relations.length} relations`);
+    }
+    catch (error) {
+        console.error(`❌ Error reading index files: ${error.message}`);
+    }
+    return { entities, relations, entries };
+}
+function createBackupFile(settings) {
+    const backupDir = join(homedir(), '.claude-mem', 'backups');
+    const backupFile = join(backupDir, `settings-backup-${Date.now()}.json`);
+    try {
+        // Ensure backup directory exists
+        if (!existsSync(backupDir)) {
+            require('fs').mkdirSync(backupDir, { recursive: true });
+        }
+        writeFileSync(backupFile, JSON.stringify(settings, null, 2));
+        console.log(`💾 Created settings backup: ${backupFile}`);
+    }
+    catch (error) {
+        console.log(`⚠️  Could not create backup: ${error.message}`);
+    }
+}
+async function performMigration(fromBackend, toBackend, options) {
+    // This function is no longer used with embedded Weaviate
+    // Migration is handled by the main migrate() function
+    console.log('Migration logic moved to main migrate() function');
+}
+export async function migrate(options = {}) {
+    console.log('🔄 Claude Memory Backend Migration');
+    console.log('==================================\n');
+    console.log('ℹ️  claude-mem now uses embedded Weaviate as the only backend.');
+    console.log('   Migration between backends is no longer needed.');
+    console.log('');
+    console.log('📊 Current Configuration:');
+    console.log('   Backend: Embedded Weaviate');
+    console.log('   Storage: Persistent across sessions');
+    console.log('   Features: Vector search, semantic similarity');
+    console.log('');
+    console.log('✅ All memory data is automatically stored in the embedded instance.');
+    console.log('');
+    console.log('💡 If you need to reset your memory data, use:');
+    console.log('     rm -rf ~/.claude-mem/weaviate-data/');
+    console.log('');
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;