claude-mem 3.0.2 → 3.0.4

package/dist/utils/mcp-client.js

@@ -0,0 +1,120 @@
+/**
+ * MCP Client for claude-mem
+ *
+ * This module provides the main interface for MCP operations in claude-mem.
+ * It uses embedded Weaviate as the only backend for persistent storage.
+ *
+ * Key Features:
+ * - Embedded Weaviate instance (no external dependencies)
+ * - Singleton pattern for efficient resource usage
+ * - Persistent storage across sessions
+ * - Clean interface matching existing usage patterns
+ */
+import { WeaviateMCPAdapter } from './weaviate-mcp-adapter.js';
+/**
+ * Singleton instance of the MCP client
+ */
+let clientInstance = null;
+let currentSettings = null;
+/**
+ * Get or create an MCP client instance
+ *
+ * This function maintains a singleton pattern using embedded Weaviate.
+ * The client persists across calls for efficient resource usage.
+ *
+ * @param settings - Configuration settings for the client (optional)
+ * @returns IMCPClient instance
+ */
+export async function getMCPClient(settings = {}) {
+    if (!clientInstance) {
+        // Create new embedded Weaviate client
+        clientInstance = new WeaviateMCPAdapter();
+        currentSettings = { ...settings };
+    }
+    return clientInstance;
+}
+/**
+ * Create a new MCP client (bypasses singleton)
+ *
+ * Use this when you need a fresh client instance without affecting
+ * the global singleton. Useful for testing or parallel operations.
+ *
+ * @param settings - Configuration settings for the client (optional)
+ * @returns New IMCPClient instance
+ */
+export async function createMCPClient(settings = {}) {
+    return new WeaviateMCPAdapter();
+}
+/**
+ * Disconnect and reset the global MCP client
+ *
+ * This function properly cleans up the singleton instance and
+ * allows for a fresh client to be created on the next call.
+ */
+export async function resetMCPClient() {
+    if (clientInstance) {
+        try {
+            await clientInstance.disconnect();
+        }
+        catch (error) {
+            console.warn('Error disconnecting MCP client during reset:', error);
+        }
+        clientInstance = null;
+        currentSettings = null;
+    }
+}
+/**
+ * Check if MCP client is connected
+ *
+ * @returns True if a client instance exists (may not be connected yet)
+ */
+export function isMCPClientActive() {
+    return clientInstance !== null;
+}
+/**
+ * Get current client settings (read-only)
+ *
+ * @returns Copy of current settings or null if no client exists
+ */
+export function getCurrentSettings() {
+    return currentSettings ? { ...currentSettings } : null;
+}
+// =============================================================================
+// CONVENIENCE METHODS
+// =============================================================================
+/**
+ * Perform an MCP operation with automatic client management
+ *
+ * This helper function automatically handles client creation, connection,
+ * and error handling for common MCP operations.
+ *
+ * @param operation - Function that performs the MCP operation
+ * @param settings - Settings for the MCP client
+ * @returns Result of the operation
+ */
+export async function withMCPClient(operation, settings = {}) {
+    const client = await getMCPClient(settings);
+    try {
+        await client.connect();
+        return await operation(client);
+    }
+    catch (error) {
+        // Don't disconnect on error - the connection might still be valid
+        // Let the next operation attempt to use the existing connection
+        throw error;
+    }
+}
+// =============================================================================
+// EXPORTS FOR BACKWARD COMPATIBILITY
+// =============================================================================
+/**
+ * Default export maintains backward compatibility
+ */
+export default {
+    getMCPClient,
+    createMCPClient,
+    resetMCPClient,
+    isMCPClientActive,
+    getCurrentSettings,
+    withMCPClient
+};

package/dist/utils/memory-mcp-client.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Memory MCP Client for claude-mem
+ *
+ * This client implements the IMCPClient interface using the traditional JSONL file-based
+ * storage system. It maintains backward compatibility with the existing claude-mem
+ * architecture while providing a clean interface for MCP operations.
+ *
+ * Key Features:
+ * - 100% backward compatibility with existing JSONL index files
+ * - Implements full IMCPClient interface
+ * - Thread-safe file operations with locking
+ * - Efficient search through in-memory indexing
+ * - Atomic writes to prevent corruption
+ */
+import { IMCPClient, MCPEntity, MCPRelation, MCPSearchResult } from '../types.js';
+/**
+ * Memory MCP Client - JSONL file-based implementation
+ *
+ * This client provides the IMCPClient interface while using the existing
+ * JSONL file storage system for backward compatibility.
+ */
+export declare class MemoryMCPClient implements IMCPClient {
+    private static instance;
+    private isConnected;
+    private cache;
+    private readonly configDir;
+    private readonly indexDir;
+    private readonly indexPath;
+    private readonly lockPath;
+    /**
+     * Singleton pattern - ensures only one instance manages file operations
+     */
+    static getInstance(): MemoryMCPClient;
+    constructor();
+    /**
+     * Connect to the memory backend (initialize file system)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the memory backend (cleanup)
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Create entities in the memory backend
+     */
+    createEntities(entities: MCPEntity[]): Promise<void>;
+    /**
+     * Create relations in the memory backend
+     */
+    createRelations(relations: MCPRelation[]): Promise<void>;
+    /**
+     * Search nodes using text-based matching
+     */
+    searchNodes(query: string): Promise<MCPSearchResult>;
+    /**
+     * Open specific nodes by exact name matching
+     */
+    openNodes(names: string[]): Promise<MCPSearchResult>;
+    /**
+     * Ensure required directories exist
+     */
+    private ensureDirectories;
+    /**
+     * Load cache from JSONL files
+     */
+    private loadCache;
+    /**
+     * Ensure cache is loaded and up to date
+     */
+    private ensureCacheLoaded;
+    /**
+     * Execute operation with file locking
+     */
+    private withFileLock;
+    /**
+     * Append entry to JSONL index file
+     */
+    private appendToIndex;
+    /**
+     * Check if entity matches search query
+     */
+    private matchesEntity;
+    /**
+     * Check if relation matches search query
+     */
+    private matchesRelation;
+    /**
+     * Generate unique ID for index entries
+     */
+    private generateId;
+    /**
+     * Generate session ID (simplified)
+     */
+    private generateSessionId;
+    /**
+     * Extract project name from entities
+     */
+    private extractProjectFromEntities;
+    /**
+     * Extract project name from relations
+     */
+    private extractProjectFromRelations;
+    /**
+     * Generate summary from entities
+     */
+    private generateSummaryFromEntities;
+    /**
+     * Generate summary from relations
+     */
+    private generateSummaryFromRelations;
+    /**
+     * Extract keywords from entities
+     */
+    private extractKeywords;
+    /**
+     * Extract keywords from relations
+     */
+    private extractKeywordsFromRelations;
+    /**
+     * Get unique nodes from relations
+     */
+    private getUniqueNodesFromRelations;
+    /**
+     * Utility method for async delays
+     */
+    private sleep;
+}
+/**
+ * Factory function to create MemoryMCPClient instance
+ */
+export declare function createMemoryMCPClient(): IMCPClient;
+/**
+ * Default export for convenience
+ */
+export default MemoryMCPClient;