@lanonasis/memory-client 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,22 +1,30 @@
 'use strict';
 
-var child_process = require('child_process');
-var util = require('util');
 var zod = require('zod');
 
 /**
- * Memory Client class for interacting with the Memory as a Service API
+ * Core Memory Client - Pure Browser-Safe Implementation
+ *
+ * NO Node.js dependencies, NO CLI code, NO child_process
+ * Works in: Browser, React Native, Cloudflare Workers, Edge Functions, Deno, Bun
+ *
+ * Bundle size: ~15KB gzipped
+ */
+/**
+ * Core Memory Client class for interacting with the Memory as a Service API
+ *
+ * This is a pure browser-safe client with zero Node.js dependencies.
+ * It uses only standard web APIs (fetch, AbortController, etc.)
  */
-class MemoryClient {
+class CoreMemoryClient {
     constructor(config) {
         this.config = {
             timeout: 30000,
-            useGateway: true,
             ...config
         };
         this.baseHeaders = {
             'Content-Type': 'application/json',
-            'User-Agent': '@lanonasis/memory-client/1.0.0',
+            'User-Agent': '@lanonasis/memory-client/2.0.0',
             ...config.headers
         };
         // Set authentication headers
@@ -26,11 +34,46 @@ class MemoryClient {
         else if (config.apiKey) {
             this.baseHeaders['X-API-Key'] = config.apiKey;
         }
+        // Add organization ID header if provided
+        if (config.organizationId) {
+            this.baseHeaders['X-Organization-ID'] = config.organizationId;
+        }
+    }
+    /**
+     * Enrich request body with organization context if configured
+     * This ensures the API has the organization_id even if not in auth token
+     */
+    enrichWithOrgContext(body) {
+        // If organizationId is configured, include it in the request body
+        if (this.config.organizationId && !body.organization_id) {
+            return {
+                ...body,
+                organization_id: this.config.organizationId
+            };
+        }
+        // Fallback to userId if no organizationId configured
+        if (!this.config.organizationId && this.config.userId && !body.organization_id) {
+            return {
+                ...body,
+                organization_id: this.config.userId
+            };
+        }
+        return body;
     }
     /**
      * Make an HTTP request to the API
      */
     async request(endpoint, options = {}) {
+        const startTime = Date.now();
+        // Call onRequest hook if provided
+        if (this.config.onRequest) {
+            try {
+                this.config.onRequest(endpoint);
+            }
+            catch (error) {
+                console.warn('onRequest hook error:', error);
+            }
+        }
         // Handle gateway vs direct API URL formatting
         const baseUrl = this.config.apiUrl.includes('/api')
             ? this.config.apiUrl.replace('/api', '')
@@ -54,16 +97,63 @@ class MemoryClient {
                 data = await response.text();
             }
             if (!response.ok) {
-                return {
-                    error: data?.error || `HTTP ${response.status}: ${response.statusText}`
+                const error = {
+                    message: data?.error || `HTTP ${response.status}: ${response.statusText}`,
+                    statusCode: response.status,
+                    code: 'API_ERROR'
                 };
+                // Call onError hook if provided
+                if (this.config.onError) {
+                    try {
+                        this.config.onError(error);
+                    }
+                    catch (hookError) {
+                        console.warn('onError hook error:', hookError);
+                    }
+                }
+                return { error: error.message };
+            }
+            // Call onResponse hook if provided
+            if (this.config.onResponse) {
+                try {
+                    const duration = Date.now() - startTime;
+                    this.config.onResponse(endpoint, duration);
+                }
+                catch (error) {
+                    console.warn('onResponse hook error:', error);
+                }
             }
             return { data };
         }
         catch (error) {
             if (error instanceof Error && error.name === 'AbortError') {
+                const timeoutError = {
+                    message: 'Request timeout',
+                    code: 'TIMEOUT_ERROR',
+                    statusCode: 408
+                };
+                if (this.config.onError) {
+                    try {
+                        this.config.onError(timeoutError);
+                    }
+                    catch (hookError) {
+                        console.warn('onError hook error:', hookError);
+                    }
+                }
                 return { error: 'Request timeout' };
             }
+            const networkError = {
+                message: error instanceof Error ? error.message : 'Network error',
+                code: 'NETWORK_ERROR'
+            };
+            if (this.config.onError) {
+                try {
+                    this.config.onError(networkError);
+                }
+                catch (hookError) {
+                    console.warn('onError hook error:', hookError);
+                }
+            }
             return {
                 error: error instanceof Error ? error.message : 'Network error'
             };
@@ -80,9 +170,10 @@ class MemoryClient {
      * Create a new memory
      */
     async createMemory(memory) {
+        const enrichedMemory = this.enrichWithOrgContext(memory);
         return this.request('/memory', {
             method: 'POST',
-            body: JSON.stringify(memory)
+            body: JSON.stringify(enrichedMemory)
         });
     }
     /**
@@ -131,18 +222,20 @@ class MemoryClient {
      * Search memories using semantic search
      */
     async searchMemories(request) {
+        const enrichedRequest = this.enrichWithOrgContext(request);
         return this.request('/memory/search', {
             method: 'POST',
-            body: JSON.stringify(request)
+            body: JSON.stringify(enrichedRequest)
         });
     }
     /**
      * Bulk delete multiple memories
      */
     async bulkDeleteMemories(memoryIds) {
+        const enrichedRequest = this.enrichWithOrgContext({ memory_ids: memoryIds });
         return this.request('/memory/bulk/delete', {
             method: 'POST',
-            body: JSON.stringify({ memory_ids: memoryIds })
+            body: JSON.stringify(enrichedRequest)
         });
     }
     // Topic Operations
@@ -150,9 +243,10 @@ class MemoryClient {
      * Create a new topic
      */
     async createTopic(topic) {
+        const enrichedTopic = this.enrichWithOrgContext(topic);
         return this.request('/topics', {
             method: 'POST',
-            body: JSON.stringify(topic)
+            body: JSON.stringify(enrichedTopic)
         });
     }
     /**
@@ -231,719 +325,10 @@ class MemoryClient {
     }
 }
 /**
- * Factory function to create a new Memory Client instance
+ * Factory function to create a new Core Memory Client instance
  */
 function createMemoryClient(config) {
-    return new MemoryClient(config);
-}
-
-/**
- * CLI Integration Module for Memory Client SDK
- *
- * Provides intelligent CLI detection and MCP channel utilization
- * when @lanonasis/cli v1.5.2+ is available in the environment
- */
-const execAsync = util.promisify(child_process.exec);
-/**
- * CLI Detection and Integration Service
- */
-class CLIIntegration {
-    constructor() {
-        this.cliInfo = null;
-        this.detectionPromise = null;
-    }
-    /**
-     * Detect if CLI is available and get its capabilities
-     */
-    async detectCLI() {
-        // Return cached result if already detected
-        if (this.cliInfo) {
-            return this.cliInfo;
-        }
-        // Return existing promise if detection is in progress
-        if (this.detectionPromise) {
-            return this.detectionPromise;
-        }
-        // Start new detection
-        this.detectionPromise = this.performDetection();
-        this.cliInfo = await this.detectionPromise;
-        return this.cliInfo;
-    }
-    async performDetection() {
-        try {
-            // Check if onasis/lanonasis CLI is available
-            let versionOutput = '';
-            try {
-                const { stdout } = await execAsync('onasis --version 2>/dev/null', { timeout: 5000 });
-                versionOutput = stdout;
-            }
-            catch {
-                // Try lanonasis if onasis fails
-                const { stdout } = await execAsync('lanonasis --version 2>/dev/null', { timeout: 5000 });
-                versionOutput = stdout;
-            }
-            const version = versionOutput.trim();
-            // Verify it's v1.5.2 or higher for Golden Contract support
-            const versionMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
-            if (!versionMatch) {
-                return { available: false };
-            }
-            const [, major, minor, patch] = versionMatch.map(Number);
-            const isCompatible = major > 1 || (major === 1 && minor > 5) || (major === 1 && minor === 5 && patch >= 2);
-            if (!isCompatible) {
-                return {
-                    available: true,
-                    version,
-                    mcpAvailable: false,
-                    authenticated: false
-                };
-            }
-            // Check MCP availability
-            let mcpAvailable = false;
-            try {
-                await execAsync('onasis mcp status --output json 2>/dev/null || lanonasis mcp status --output json 2>/dev/null', {
-                    timeout: 3000
-                });
-                mcpAvailable = true;
-            }
-            catch {
-                // MCP not available or not configured
-            }
-            // Check authentication status
-            let authenticated = false;
-            try {
-                const { stdout: authOutput } = await execAsync('onasis auth status --output json 2>/dev/null || lanonasis auth status --output json 2>/dev/null', {
-                    timeout: 3000
-                });
-                const authStatus = JSON.parse(authOutput);
-                authenticated = authStatus.authenticated === true;
-            }
-            catch {
-                // Authentication check failed
-            }
-            return {
-                available: true,
-                version,
-                mcpAvailable,
-                authenticated
-            };
-        }
-        catch {
-            return { available: false };
-        }
-    }
-    /**
-     * Execute CLI command and return parsed JSON result
-     */
-    async executeCLICommand(command, options = {}) {
-        const cliInfo = await this.detectCLI();
-        if (!cliInfo.available) {
-            return { error: 'CLI not available' };
-        }
-        if (!cliInfo.authenticated) {
-            return { error: 'CLI not authenticated. Run: onasis login' };
-        }
-        try {
-            const timeout = options.timeout || 30000;
-            const outputFormat = options.outputFormat || 'json';
-            const verbose = options.verbose ? '--verbose' : '';
-            // Determine which CLI command to use (prefer onasis for Golden Contract)
-            const cliCmd = await this.getPreferredCLICommand();
-            const fullCommand = `${cliCmd} ${command} --output ${outputFormat} ${verbose}`.trim();
-            const { stdout, stderr } = await execAsync(fullCommand, {
-                timeout,
-                maxBuffer: 1024 * 1024 // 1MB buffer
-            });
-            if (stderr && stderr.trim()) {
-                console.warn('CLI warning:', stderr);
-            }
-            if (outputFormat === 'json') {
-                try {
-                    const result = JSON.parse(stdout);
-                    return { data: result };
-                }
-                catch (parseError) {
-                    return { error: `Failed to parse CLI JSON output: ${parseError instanceof Error ? parseError.message : 'Unknown error'}` };
-                }
-            }
-            return { data: stdout };
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timeout')) {
-                return { error: 'CLI command timeout' };
-            }
-            return {
-                error: error instanceof Error ? error.message : 'CLI command failed'
-            };
-        }
-    }
-    /**
-     * Get preferred CLI command (onasis for Golden Contract, fallback to lanonasis)
-     */
-    async getPreferredCLICommand() {
-        try {
-            child_process.execSync('which onasis', { stdio: 'ignore', timeout: 1000 });
-            return 'onasis';
-        }
-        catch {
-            return 'lanonasis';
-        }
-    }
-    /**
-     * Memory operations via CLI
-     */
-    async createMemoryViaCLI(title, content, options = {}) {
-        const { memoryType = 'context', tags = [], topicId } = options;
-        let command = `memory create --title "${title}" --content "${content}" --memory-type ${memoryType}`;
-        if (tags.length > 0) {
-            command += ` --tags "${tags.join(',')}"`;
-        }
-        if (topicId) {
-            command += ` --topic-id "${topicId}"`;
-        }
-        return this.executeCLICommand(command);
-    }
-    async listMemoriesViaCLI(options = {}) {
-        let command = 'memory list';
-        if (options.limit) {
-            command += ` --limit ${options.limit}`;
-        }
-        if (options.memoryType) {
-            command += ` --memory-type ${options.memoryType}`;
-        }
-        if (options.tags && options.tags.length > 0) {
-            command += ` --tags "${options.tags.join(',')}"`;
-        }
-        if (options.sortBy) {
-            command += ` --sort-by ${options.sortBy}`;
-        }
-        return this.executeCLICommand(command);
-    }
-    async searchMemoriesViaCLI(query, options = {}) {
-        let command = `memory search "${query}"`;
-        if (options.limit) {
-            command += ` --limit ${options.limit}`;
-        }
-        if (options.memoryTypes && options.memoryTypes.length > 0) {
-            command += ` --memory-types "${options.memoryTypes.join(',')}"`;
-        }
-        return this.executeCLICommand(command);
-    }
-    /**
-     * Health check via CLI
-     */
-    async healthCheckViaCLI() {
-        return this.executeCLICommand('health');
-    }
-    /**
-     * MCP-specific operations
-     */
-    async getMCPStatus() {
-        const cliInfo = await this.detectCLI();
-        if (!cliInfo.mcpAvailable) {
-            return { error: 'MCP not available via CLI' };
-        }
-        return this.executeCLICommand('mcp status');
-    }
-    async listMCPTools() {
-        const cliInfo = await this.detectCLI();
-        if (!cliInfo.mcpAvailable) {
-            return { error: 'MCP not available via CLI' };
-        }
-        return this.executeCLICommand('mcp tools');
-    }
-    /**
-     * Authentication operations
-     */
-    async getAuthStatus() {
-        return this.executeCLICommand('auth status');
-    }
-    /**
-     * Check if specific CLI features are available
-     */
-    async getCapabilities() {
-        const cliInfo = await this.detectCLI();
-        return {
-            cliAvailable: cliInfo.available,
-            version: cliInfo.version,
-            mcpSupport: cliInfo.mcpAvailable || false,
-            authenticated: cliInfo.authenticated || false,
-            goldenContract: cliInfo.available && this.isGoldenContractCompliant(cliInfo.version)
-        };
-    }
-    isGoldenContractCompliant(version) {
-        if (!version)
-            return false;
-        const versionMatch = version.match(/(\d+)\.(\d+)\.(\d+)/);
-        if (!versionMatch)
-            return false;
-        const [, major, minor, patch] = versionMatch.map(Number);
-        return major > 1 || (major === 1 && minor > 5) || (major === 1 && minor === 5 && patch >= 2);
-    }
-    /**
-     * Force refresh CLI detection
-     */
-    async refresh() {
-        this.cliInfo = null;
-        this.detectionPromise = null;
-        return this.detectCLI();
-    }
-    /**
-     * Get cached CLI info without re-detection
-     */
-    getCachedInfo() {
-        return this.cliInfo;
-    }
-}
-
-/**
- * Enhanced Memory Client with CLI Integration
- *
- * Intelligently routes requests through CLI v1.5.2+ when available,
- * with fallback to direct API for maximum compatibility and performance
- */
-/**
- * Enhanced Memory Client with intelligent CLI/API routing
- */
-class EnhancedMemoryClient {
-    createDefaultCapabilities() {
-        return {
-            cliAvailable: false,
-            mcpSupport: false,
-            authenticated: false,
-            goldenContract: false
-        };
-    }
-    constructor(config) {
-        this.capabilities = null;
-        this.config = {
-            preferCLI: true,
-            enableMCP: true,
-            cliDetectionTimeout: 5000,
-            fallbackToAPI: true,
-            minCLIVersion: '1.5.2',
-            verbose: false,
-            timeout: 30000,
-            useGateway: true,
-            apiKey: config.apiKey || process.env.LANONASIS_API_KEY || '',
-            authToken: config.authToken || '',
-            headers: config.headers || {},
-            ...config
-        };
-        this.directClient = new MemoryClient(config);
-        this.cliIntegration = new CLIIntegration();
-    }
-    /**
-     * Initialize the client and detect capabilities
-     */
-    async initialize() {
-        try {
-            const detectionPromise = this.cliIntegration.getCapabilities();
-            const capabilities = this.config.cliDetectionTimeout > 0
-                ? await Promise.race([
-                    detectionPromise,
-                    new Promise((resolve) => {
-                        setTimeout(() => resolve(null), this.config.cliDetectionTimeout);
-                    })
-                ])
-                : await detectionPromise;
-            if (capabilities) {
-                this.capabilities = capabilities;
-                if (this.config.verbose && capabilities.cliAvailable && !capabilities.authenticated) {
-                    const suggestedCommand = capabilities.goldenContract ? 'onasis login' : 'lanonasis login';
-                    console.warn(`CLI detected but not authenticated. Run '${suggestedCommand}' to enable enhanced SDK features.`);
-                }
-            }
-            else {
-                this.capabilities = this.createDefaultCapabilities();
-                if (this.config.verbose) {
-                    console.warn(`CLI detection timed out after ${this.config.cliDetectionTimeout}ms. Falling back to API mode.`);
-                }
-            }
-        }
-        catch (error) {
-            if (this.config.verbose) {
-                console.warn('CLI detection failed:', error);
-            }
-            this.capabilities = this.createDefaultCapabilities();
-        }
-    }
-    /**
-     * Get current capabilities
-     */
-    async getCapabilities() {
-        if (!this.capabilities) {
-            await this.initialize();
-        }
-        return this.capabilities;
-    }
-    /**
-     * Determine if operation should use CLI
-     */
-    async shouldUseCLI() {
-        const capabilities = await this.getCapabilities();
-        return (this.config.preferCLI &&
-            capabilities.cliAvailable &&
-            capabilities.authenticated &&
-            capabilities.goldenContract);
-    }
-    /**
-     * Execute operation with intelligent routing
-     */
-    async executeOperation(operation, cliOperation, apiOperation) {
-        const useCLI = await this.shouldUseCLI();
-        const capabilities = await this.getCapabilities();
-        if (useCLI) {
-            try {
-                const result = await cliOperation();
-                if (result.error && this.config.fallbackToAPI) {
-                    console.warn(`CLI ${operation} failed, falling back to API:`, result.error);
-                    const apiResult = await apiOperation();
-                    return {
-                        ...apiResult,
-                        source: 'api',
-                        mcpUsed: false
-                    };
-                }
-                return {
-                    ...result,
-                    source: 'cli',
-                    mcpUsed: capabilities.mcpSupport
-                };
-            }
-            catch (error) {
-                if (this.config.fallbackToAPI) {
-                    console.warn(`CLI ${operation} error, falling back to API:`, error);
-                    const apiResult = await apiOperation();
-                    return {
-                        ...apiResult,
-                        source: 'api',
-                        mcpUsed: false
-                    };
-                }
-                return {
-                    error: error instanceof Error ? error.message : `CLI ${operation} failed`,
-                    source: 'cli',
-                    mcpUsed: false
-                };
-            }
-        }
-        else {
-            const result = await apiOperation();
-            return {
-                ...result,
-                source: 'api',
-                mcpUsed: false
-            };
-        }
-    }
-    // Enhanced API Methods
-    /**
-     * Health check with intelligent routing
-     */
-    async healthCheck() {
-        return this.executeOperation('health check', () => this.cliIntegration.healthCheckViaCLI(), () => this.directClient.healthCheck());
-    }
-    /**
-     * Create memory with CLI/API routing
-     */
-    async createMemory(memory) {
-        return this.executeOperation('create memory', () => this.cliIntegration.createMemoryViaCLI(memory.title, memory.content, {
-            memoryType: memory.memory_type,
-            tags: memory.tags,
-            topicId: memory.topic_id
-        }), () => this.directClient.createMemory(memory));
-    }
-    /**
-     * List memories with intelligent routing
-     */
-    async listMemories(options = {}) {
-        return this.executeOperation('list memories', () => this.cliIntegration.listMemoriesViaCLI({
-            limit: options.limit,
-            memoryType: options.memory_type,
-            tags: options.tags,
-            sortBy: options.sort
-        }), () => this.directClient.listMemories(options));
-    }
-    /**
-     * Search memories with MCP enhancement when available
-     */
-    async searchMemories(request) {
-        return this.executeOperation('search memories', () => this.cliIntegration.searchMemoriesViaCLI(request.query, {
-            limit: request.limit,
-            memoryTypes: request.memory_types
-        }), () => this.directClient.searchMemories(request));
-    }
-    /**
-     * Get memory by ID (API only for now)
-     */
-    async getMemory(id) {
-        // CLI doesn't have get by ID yet, use API
-        const result = await this.directClient.getMemory(id);
-        return {
-            ...result,
-            source: 'api',
-            mcpUsed: false
-        };
-    }
-    /**
-     * Update memory (API only for now)
-     */
-    async updateMemory(id, updates) {
-        // CLI doesn't have update yet, use API
-        const result = await this.directClient.updateMemory(id, updates);
-        return {
-            ...result,
-            source: 'api',
-            mcpUsed: false
-        };
-    }
-    /**
-     * Delete memory (API only for now)
-     */
-    async deleteMemory(id) {
-        // CLI doesn't have delete yet, use API
-        const result = await this.directClient.deleteMemory(id);
-        return {
-            ...result,
-            source: 'api',
-            mcpUsed: false
-        };
-    }
-    // Topic Operations (API only for now)
-    async createTopic(topic) {
-        const result = await this.directClient.createTopic(topic);
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    async getTopics() {
-        const result = await this.directClient.getTopics();
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    async getTopic(id) {
-        const result = await this.directClient.getTopic(id);
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    async updateTopic(id, updates) {
-        const result = await this.directClient.updateTopic(id, updates);
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    async deleteTopic(id) {
-        const result = await this.directClient.deleteTopic(id);
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    /**
-     * Get memory statistics
-     */
-    async getMemoryStats() {
-        const result = await this.directClient.getMemoryStats();
-        return { ...result, source: 'api', mcpUsed: false };
-    }
-    // Utility Methods
-    /**
-     * Force CLI re-detection
-     */
-    async refreshCLIDetection() {
-        this.capabilities = null;
-        await this.cliIntegration.refresh();
-        await this.initialize();
-    }
-    /**
-     * Get authentication status from CLI
-     */
-    async getAuthStatus() {
-        try {
-            const result = await this.cliIntegration.getAuthStatus();
-            return { ...result, source: 'cli', mcpUsed: false };
-        }
-        catch (error) {
-            return {
-                error: error instanceof Error ? error.message : 'Auth status check failed',
-                source: 'cli',
-                mcpUsed: false
-            };
-        }
-    }
-    /**
-     * Get MCP status when available
-     */
-    async getMCPStatus() {
-        const capabilities = await this.getCapabilities();
-        if (!capabilities.mcpSupport) {
-            return {
-                error: 'MCP not available',
-                source: 'cli',
-                mcpUsed: false
-            };
-        }
-        try {
-            const result = await this.cliIntegration.getMCPStatus();
-            return { ...result, source: 'cli', mcpUsed: true };
-        }
-        catch (error) {
-            return {
-                error: error instanceof Error ? error.message : 'MCP status check failed',
-                source: 'cli',
-                mcpUsed: false
-            };
-        }
-    }
-    /**
-     * Update authentication for both CLI and API client
-     */
-    setAuthToken(token) {
-        this.directClient.setAuthToken(token);
-    }
-    setApiKey(apiKey) {
-        this.directClient.setApiKey(apiKey);
-    }
-    clearAuth() {
-        this.directClient.clearAuth();
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-        this.directClient.updateConfig(updates);
-    }
-    /**
-     * Get configuration summary
-     */
-    getConfigSummary() {
-        return {
-            apiUrl: this.config.apiUrl,
-            preferCLI: this.config.preferCLI,
-            enableMCP: this.config.enableMCP,
-            capabilities: this.capabilities || undefined
-        };
-    }
-}
-/**
- * Factory function to create an enhanced memory client
- */
-async function createEnhancedMemoryClient(config) {
-    const client = new EnhancedMemoryClient(config);
-    await client.initialize();
-    return client;
-}
-
-/**
- * Configuration utilities for Memory Client SDK
- * Provides smart defaults and environment detection for CLI/MCP integration
- */
-/**
- * Environment detection utilities
- */
-const Environment = {
-    isNode: typeof globalThis !== 'undefined' && 'process' in globalThis && globalThis.process?.versions?.node,
-    isBrowser: typeof window !== 'undefined',
-    isVSCode: typeof globalThis !== 'undefined' && 'vscode' in globalThis,
-    isCursor: typeof globalThis !== 'undefined' && 'cursor' in globalThis,
-    isWindsurf: typeof globalThis !== 'undefined' && 'windsurf' in globalThis,
-    get isIDE() {
-        return this.isVSCode || this.isCursor || this.isWindsurf;
-    },
-    get supportsCLI() {
-        return Boolean(this.isNode && !this.isBrowser);
-    }
-};
-/**
- * Create smart configuration with environment-aware defaults
- */
-function createSmartConfig(baseConfig, options = {}) {
-    const defaults = {
-        preferCLI: Environment.supportsCLI,
-        minCLIVersion: '1.5.2',
-        enableMCP: true,
-        cliDetectionTimeout: 3000,
-        verbose: false
-    };
-    const config = { ...defaults, ...options };
-    return {
-        ...baseConfig,
-        preferCLI: config.preferCLI,
-        minCLIVersion: config.minCLIVersion,
-        enableMCP: config.enableMCP,
-        cliDetectionTimeout: config.cliDetectionTimeout,
-        verbose: config.verbose,
-        // Smart API configuration with environment detection
-        apiUrl: baseConfig.apiUrl || (process?.env?.NODE_ENV === 'development'
-            ? 'http://localhost:3001'
-            : 'https://api.lanonasis.com'),
-        // Default timeout based on environment
-        timeout: baseConfig.timeout || (Environment.isIDE ? 10000 : 15000)
-    };
-}
-/**
- * Preset configurations for common scenarios
- */
-const ConfigPresets = {
-    /**
-     * Development configuration with local API and CLI preference
-     */
-    development: (apiKey) => createSmartConfig({
-        apiUrl: 'http://localhost:3001',
-        apiKey,
-        timeout: 30000
-    }, {
-        preferCLI: true,
-        verbose: true
-    }),
-    /**
-     * Production configuration optimized for performance
-     */
-    production: (apiKey) => createSmartConfig({
-        apiUrl: 'https://api.lanonasis.com',
-        apiKey,
-        timeout: 15000
-    }, {
-        preferCLI: Environment.supportsCLI,
-        verbose: false
-    }),
-    /**
-     * IDE extension configuration with MCP prioritization
-     */
-    ideExtension: (apiKey) => createSmartConfig({
-        apiUrl: 'https://api.lanonasis.com',
-        apiKey,
-        timeout: 10000
-    }, {
-        preferCLI: true,
-        enableMCP: true,
-        cliDetectionTimeout: 2000
-    }),
-    /**
-     * Browser-only configuration (no CLI support)
-     */
-    browserOnly: (apiKey) => createSmartConfig({
-        apiUrl: 'https://api.lanonasis.com',
-        apiKey,
-        timeout: 15000
-    }, {
-        preferCLI: false,
-        enableMCP: false
-    }),
-    /**
-     * CLI-first configuration for server environments
-     */
-    serverCLI: (apiKey) => createSmartConfig({
-        apiUrl: 'https://api.lanonasis.com',
-        apiKey,
-        timeout: 20000
-    }, {
-        preferCLI: true,
-        enableMCP: true,
-        verbose: false
-    })
-};
-/**
- * Migration helper for existing MemoryClient users
- */
-function migrateToEnhanced(existingConfig, enhancementOptions = {}) {
-    return createSmartConfig(existingConfig, {
-        preferCLI: Environment.supportsCLI,
-        ...enhancementOptions
-    });
+    return new CoreMemoryClient(config);
 }
 
 /**
@@ -965,7 +350,7 @@ const createMemorySchema = zod.z.object({
     topic_id: zod.z.string().uuid().optional(),
     project_ref: zod.z.string().max(100).optional(),
     tags: zod.z.array(zod.z.string().min(1).max(50)).max(20).default([]),
-    metadata: zod.z.record(zod.z.unknown()).optional()
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
 const updateMemorySchema = zod.z.object({
     title: zod.z.string().min(1).max(500).optional(),
@@ -976,7 +361,7 @@ const updateMemorySchema = zod.z.object({
     topic_id: zod.z.string().uuid().nullable().optional(),
     project_ref: zod.z.string().max(100).nullable().optional(),
     tags: zod.z.array(zod.z.string().min(1).max(50)).max(20).optional(),
-    metadata: zod.z.record(zod.z.unknown()).optional()
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
 const searchMemorySchema = zod.z.object({
     query: zod.z.string().min(1).max(1000),
@@ -996,57 +381,257 @@ const createTopicSchema = zod.z.object({
     parent_topic_id: zod.z.string().uuid().optional()
 });
 
+/**
+ * Error handling for Memory Client
+ * Browser-safe, no Node.js dependencies
+ */
+/**
+ * Base error class for Memory Client errors
+ */
+class MemoryClientError extends Error {
+    constructor(message, code, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'MemoryClientError';
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, MemoryClientError);
+        }
+    }
+}
+/**
+ * Network/API error
+ */
+class ApiError extends MemoryClientError {
+    constructor(message, statusCode, details) {
+        super(message, 'API_ERROR', statusCode, details);
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Authentication error
+ */
+class AuthenticationError extends MemoryClientError {
+    constructor(message = 'Authentication required') {
+        super(message, 'AUTH_ERROR', 401);
+        this.name = 'AuthenticationError';
+    }
+}
+/**
+ * Validation error
+ */
+class ValidationError extends MemoryClientError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', 400, details);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Timeout error
+ */
+class TimeoutError extends MemoryClientError {
+    constructor(message = 'Request timeout') {
+        super(message, 'TIMEOUT_ERROR', 408);
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ * Rate limit error
+ */
+class RateLimitError extends MemoryClientError {
+    constructor(message = 'Rate limit exceeded') {
+        super(message, 'RATE_LIMIT_ERROR', 429);
+        this.name = 'RateLimitError';
+    }
+}
+/**
+ * Not found error
+ */
+class NotFoundError extends MemoryClientError {
+    constructor(resource) {
+        super(`${resource} not found`, 'NOT_FOUND', 404);
+        this.name = 'NotFoundError';
+    }
+}
+
 /**
  * @lanonasis/memory-client
  *
- * Memory as a Service (MaaS) Client SDK for Lanonasis
+ * Universal Memory as a Service (MaaS) Client SDK for Lanonasis
  * Intelligent memory management with semantic search capabilities
+ *
+ * v2.0.0 - Universal SDK Redesign
+ * "Drop In and Sleep" Architecture - Works everywhere with zero configuration
+ *
+ * @example Browser/Web App
+ * ```ts
+ * import { createMemoryClient } from '@lanonasis/memory-client/core';
+ * const client = createMemoryClient({ apiKey: 'your-key' });
+ * ```
+ *
+ * @example Node.js
+ * ```ts
+ * import { createNodeMemoryClient } from '@lanonasis/memory-client/node';
+ * const client = await createNodeMemoryClient({ apiKey: process.env.KEY });
+ * ```
+ *
+ * @example React
+ * ```tsx
+ * import { MemoryProvider, useMemories } from '@lanonasis/memory-client/react';
+ * ```
+ *
+ * @example Vue
+ * ```ts
+ * import { createMemoryPlugin, useMemories } from '@lanonasis/memory-client/vue';
+ * ```
  */
-// Main client
+// ========================================
+// Core Exports (Browser-Safe)
+// ========================================
+// ========================================
 // Constants
-const VERSION = '1.0.0';
+// ========================================
+const VERSION = '2.0.0';
 const CLIENT_NAME = '@lanonasis/memory-client';
-// Environment detection
+// ========================================
+// Environment Detection
+// ========================================
 const isBrowser = typeof window !== 'undefined';
 const isNode = typeof globalThis !== 'undefined' && 'process' in globalThis && globalThis.process?.versions?.node;
-// Default configurations for different environments
+// ========================================
+// Default Configurations
+// ========================================
 const defaultConfigs = {
     development: {
         apiUrl: 'http://localhost:3001',
         timeout: 30000,
-        useGateway: false
     },
     production: {
         apiUrl: 'https://api.lanonasis.com',
         timeout: 15000,
-        useGateway: true
     },
-    gateway: {
+    edge: {
         apiUrl: 'https://api.lanonasis.com',
-        timeout: 10000,
-        useGateway: true
+        timeout: 5000,
     }
 };
-// Utility functions will be added in a future version to avoid circular imports
+// Note: Enhanced client requires Node.js, so we don't export it from main entry
+// Users should import from '@lanonasis/memory-client/node' instead
+// ========================================
+// Usage Instructions
+// ========================================
+/**
+ * # @lanonasis/memory-client v2.0
+ *
+ * ## Quick Start
+ *
+ * ### Browser / Web App
+ * ```bash
+ * npm install @lanonasis/memory-client
+ * ```
+ * ```typescript
+ * import { createMemoryClient } from '@lanonasis/memory-client/core';
+ *
+ * const client = createMemoryClient({
+ *   apiUrl: 'https://api.lanonasis.com',
+ *   apiKey: 'your-key-here'
+ * });
+ *
+ * const memories = await client.listMemories();
+ * ```
+ *
+ * ### Node.js with CLI Support
+ * ```typescript
+ * import { createNodeMemoryClient } from '@lanonasis/memory-client/node';
+ *
+ * const client = await createNodeMemoryClient({
+ *   apiKey: process.env.LANONASIS_KEY,
+ *   preferCLI: true // Automatically uses CLI if available
+ * });
+ *
+ * const result = await client.listMemories();
+ * console.log(`Using: ${result.source}`); // 'cli' or 'api'
+ * ```
+ *
+ * ### React
+ * ```tsx
+ * import { MemoryProvider, useMemories } from '@lanonasis/memory-client/react';
+ *
+ * function App() {
+ *   return (
+ *     <MemoryProvider apiKey="your-key">
+ *       <MemoryList />
+ *     </MemoryProvider>
+ *   );
+ * }
+ *
+ * function MemoryList() {
+ *   const { memories, loading } = useMemories();
+ *   if (loading) return <div>Loading...</div>;
+ *   return <div>{memories.map(m => <div key={m.id}>{m.title}</div>)}</div>;
+ * }
+ * ```
+ *
+ * ### Vue 3
+ * ```typescript
+ * import { createMemoryPlugin, useMemories } from '@lanonasis/memory-client/vue';
+ *
+ * const app = createApp(App);
+ * app.use(createMemoryPlugin({ apiKey: 'your-key' }));
+ * ```
+ *
+ * ### Edge Functions (Cloudflare Workers, Vercel Edge)
+ * ```typescript
+ * import { createMemoryClient } from '@lanonasis/memory-client/core';
+ * import { edgePreset } from '@lanonasis/memory-client/presets';
+ *
+ * export default {
+ *   async fetch(request: Request, env: Env) {
+ *     const client = createMemoryClient(edgePreset({
+ *       apiKey: env.LANONASIS_KEY
+ *     }));
+ *     const memories = await client.searchMemories({ query: 'test' });
+ *     return Response.json(memories.data);
+ *   }
+ * };
+ * ```
+ *
+ * ## Bundle Sizes
+ *
+ * - **Core** (browser): ~15KB gzipped
+ * - **Node** (with CLI): ~35KB gzipped
+ * - **React**: ~18KB gzipped (+ React)
+ * - **Vue**: ~17KB gzipped (+ Vue)
+ * - **Presets**: ~2KB gzipped
+ *
+ * ## Documentation
+ *
+ * - Full docs: https://docs.lanonasis.com/sdk
+ * - API reference: https://docs.lanonasis.com/api
+ * - Examples: https://github.com/lanonasis/examples
+ */
 
+exports.ApiErrorClass = ApiError;
+exports.AuthenticationError = AuthenticationError;
 exports.CLIENT_NAME = CLIENT_NAME;
-exports.CLIIntegration = CLIIntegration;
-exports.ConfigPresets = ConfigPresets;
-exports.EnhancedMemoryClient = EnhancedMemoryClient;
-exports.Environment = Environment;
+exports.CoreMemoryClient = CoreMemoryClient;
 exports.MEMORY_STATUSES = MEMORY_STATUSES;
 exports.MEMORY_TYPES = MEMORY_TYPES;
-exports.MemoryClient = MemoryClient;
+exports.MemoryClient = CoreMemoryClient;
+exports.MemoryClientError = MemoryClientError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.TimeoutError = TimeoutError;
 exports.VERSION = VERSION;
-exports.createEnhancedMemoryClient = createEnhancedMemoryClient;
+exports.ValidationError = ValidationError;
 exports.createMemoryClient = createMemoryClient;
 exports.createMemorySchema = createMemorySchema;
-exports.createSmartConfig = createSmartConfig;
 exports.createTopicSchema = createTopicSchema;
 exports.defaultConfigs = defaultConfigs;
 exports.isBrowser = isBrowser;
 exports.isNode = isNode;
-exports.migrateToEnhanced = migrateToEnhanced;
 exports.searchMemorySchema = searchMemorySchema;
 exports.updateMemorySchema = updateMemorySchema;
 //# sourceMappingURL=index.js.map