@lanonasis/memory-client 2.1.0 → 2.2.0

package/dist/index.cjs

@@ -0,0 +1,1918 @@
+'use strict';
+
+var zod = require('zod');
+var child_process = require('child_process');
+var util = require('util');
+
+/**
+ * Memory types supported by the service
+ */
+const MEMORY_TYPES = ['context', 'project', 'knowledge', 'reference', 'personal', 'workflow'];
+/**
+ * Memory status values
+ */
+const MEMORY_STATUSES = ['active', 'archived', 'draft', 'deleted'];
+/**
+ * Validation schemas using Zod
+ */
+const createMemorySchema = zod.z.object({
+    title: zod.z.string().min(1).max(500),
+    content: zod.z.string().min(1).max(50000),
+    summary: zod.z.string().max(1000).optional(),
+    memory_type: zod.z.enum(MEMORY_TYPES).default('context'),
+    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.string(), zod.z.unknown()).optional()
+});
+const updateMemorySchema = zod.z.object({
+    title: zod.z.string().min(1).max(500).optional(),
+    content: zod.z.string().min(1).max(50000).optional(),
+    summary: zod.z.string().max(1000).optional(),
+    memory_type: zod.z.enum(MEMORY_TYPES).optional(),
+    status: zod.z.enum(MEMORY_STATUSES).optional(),
+    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.string(), zod.z.unknown()).optional()
+});
+const searchMemorySchema = zod.z.object({
+    query: zod.z.string().min(1).max(1000),
+    memory_types: zod.z.array(zod.z.enum(MEMORY_TYPES)).optional(),
+    tags: zod.z.array(zod.z.string()).optional(),
+    topic_id: zod.z.string().uuid().optional(),
+    project_ref: zod.z.string().optional(),
+    status: zod.z.enum(MEMORY_STATUSES).default('active'),
+    limit: zod.z.number().int().min(1).max(100).default(20),
+    threshold: zod.z.number().min(0).max(1).default(0.7)
+});
+const createTopicSchema = zod.z.object({
+    name: zod.z.string().min(1).max(100),
+    description: zod.z.string().max(500).optional(),
+    color: zod.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+    icon: zod.z.string().max(50).optional(),
+    parent_topic_id: zod.z.string().uuid().optional()
+});
+zod.z
+    .object({
+    memory_id: zod.z.string().uuid().optional(),
+    content: zod.z.string().min(1).optional(),
+    title: zod.z.string().optional(),
+    existing_tags: zod.z.array(zod.z.string()).optional(),
+    max_suggestions: zod.z.number().int().min(1).max(10).optional()
+})
+    .refine((data) => data.memory_id || data.content, {
+    message: 'Either memory_id or content is required'
+});
+zod.z.object({
+    time_range_days: zod.z.number().int().min(1).max(365).optional(),
+    include_insights: zod.z.boolean().optional(),
+    response_format: zod.z.enum(['json', 'markdown']).optional()
+});
+zod.z.object({
+    include_recommendations: zod.z.boolean().optional(),
+    detailed_breakdown: zod.z.boolean().optional()
+});
+zod.z
+    .object({
+    memory_id: zod.z.string().uuid().optional(),
+    query: zod.z.string().min(1).optional(),
+    limit: zod.z.number().int().min(1).max(20).optional(),
+    similarity_threshold: zod.z.number().min(0).max(1).optional(),
+    exclude_ids: zod.z.array(zod.z.string().uuid()).optional()
+})
+    .refine((data) => data.memory_id || data.query, {
+    message: 'Either memory_id or query is required'
+});
+zod.z.object({
+    similarity_threshold: zod.z.number().min(0).max(1).optional(),
+    include_archived: zod.z.boolean().optional(),
+    limit: zod.z.number().int().min(1).max(50).optional()
+});
+zod.z.object({
+    memory_ids: zod.z.array(zod.z.string().uuid()).optional(),
+    topic: zod.z.string().min(1).optional(),
+    time_range_days: zod.z.number().int().min(1).max(365).optional(),
+    insight_types: zod.z.array(zod.z.enum(['themes', 'connections', 'gaps', 'actions', 'summary'])).optional(),
+    detail_level: zod.z.enum(['brief', 'detailed', 'comprehensive']).optional()
+});
+// ========================================
+// Intelligence Feature Types (v2.0)
+// ========================================
+/**
+ * Chunking strategies for content preprocessing
+ */
+const CHUNKING_STRATEGIES = ['semantic', 'fixed-size', 'paragraph', 'sentence', 'code-block'];
+/**
+ * Content types detected or specified
+ */
+const CONTENT_TYPES = ['text', 'code', 'markdown', 'json', 'yaml'];
+// ========================================
+// Enhanced Search Types
+// ========================================
+/**
+ * Search modes for memory queries
+ */
+const SEARCH_MODES = ['vector', 'text', 'hybrid'];
+// ========================================
+// Validation Schemas for Intelligence
+// ========================================
+const preprocessingOptionsSchema = zod.z.object({
+    chunking: zod.z.object({
+        strategy: zod.z.enum(CHUNKING_STRATEGIES).optional(),
+        maxChunkSize: zod.z.number().int().min(100).max(10000).optional(),
+        overlap: zod.z.number().int().min(0).max(500).optional()
+    }).optional(),
+    cleanContent: zod.z.boolean().optional(),
+    extractMetadata: zod.z.boolean().optional()
+}).optional();
+const enhancedSearchSchema = zod.z.object({
+    query: zod.z.string().min(1).max(1000),
+    type: zod.z.enum(MEMORY_TYPES).optional(),
+    threshold: zod.z.number().min(0).max(1).default(0.7),
+    limit: zod.z.number().int().min(1).max(100).default(20),
+    search_mode: zod.z.enum(SEARCH_MODES).default('hybrid'),
+    filters: zod.z.object({
+        tags: zod.z.array(zod.z.string()).optional(),
+        project_id: zod.z.string().uuid().optional(),
+        topic_id: zod.z.string().uuid().optional(),
+        date_range: zod.z.object({
+            from: zod.z.string().optional(),
+            to: zod.z.string().optional()
+        }).optional()
+    }).optional(),
+    include_chunks: zod.z.boolean().default(false)
+});
+const analyticsDateRangeSchema = zod.z.object({
+    from: zod.z.string().optional(),
+    to: zod.z.string().optional(),
+    group_by: zod.z.enum(['day', 'week', 'month']).default('day')
+});
+
+/**
+ * Core Utilities for Memory Client
+ * Browser-safe, no Node.js dependencies
+ */
+/**
+ * Safely parse JSON with detailed error reporting
+ * Prevents scattered try/catch blocks throughout the codebase
+ */
+function safeJsonParse(input) {
+    try {
+        const data = JSON.parse(input);
+        return { success: true, data };
+    }
+    catch (error) {
+        const message = error instanceof Error
+            ? error.message
+            : 'Unknown JSON parse error';
+        return { success: false, error: `Invalid JSON: ${message}` };
+    }
+}
+/**
+ * HTTP status code to error code mapping
+ */
+function httpStatusToErrorCode(status) {
+    switch (status) {
+        case 400:
+            return 'VALIDATION_ERROR';
+        case 401:
+            return 'AUTH_ERROR';
+        case 403:
+            return 'FORBIDDEN';
+        case 404:
+            return 'NOT_FOUND';
+        case 408:
+            return 'TIMEOUT_ERROR';
+        case 409:
+            return 'CONFLICT';
+        case 429:
+            return 'RATE_LIMIT_ERROR';
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            return 'SERVER_ERROR';
+        default:
+            return 'API_ERROR';
+    }
+}
+/**
+ * Create a standardized error response from various error sources
+ */
+function createErrorResponse(message, code = 'API_ERROR', statusCode, details) {
+    return {
+        code,
+        message,
+        statusCode,
+        details,
+        timestamp: new Date().toISOString()
+    };
+}
+/**
+ * Create an error response from an HTTP response
+ */
+function createErrorFromResponse(status, statusText, body) {
+    const code = httpStatusToErrorCode(status);
+    // Try to extract message from response body
+    let message = `HTTP ${status}: ${statusText}`;
+    let details = undefined;
+    if (body && typeof body === 'object') {
+        const bodyObj = body;
+        if (typeof bodyObj.error === 'string') {
+            message = bodyObj.error;
+        }
+        else if (typeof bodyObj.message === 'string') {
+            message = bodyObj.message;
+        }
+        if (bodyObj.details) {
+            details = bodyObj.details;
+        }
+    }
+    return createErrorResponse(message, code, status, details);
+}
+/**
+ * Sleep utility for retry logic
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Calculate retry delay with exponential backoff and jitter
+ */
+function calculateRetryDelay(attempt, baseDelay = 1000, backoff = 'exponential', maxDelay = 30000) {
+    let delay;
+    if (backoff === 'exponential') {
+        delay = baseDelay * Math.pow(2, attempt);
+    }
+    else {
+        delay = baseDelay * (attempt + 1);
+    }
+    // Add jitter (±20%) to prevent thundering herd
+    const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+    delay = Math.min(delay + jitter, maxDelay);
+    return Math.round(delay);
+}
+/**
+ * Check if an error is retryable based on status code
+ */
+function isRetryableError(statusCode) {
+    if (!statusCode)
+        return true; // Network errors are retryable
+    // Retry on server errors and rate limits
+    return statusCode >= 500 || statusCode === 429 || statusCode === 408;
+}
+
+/**
+ * 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
+ */
+/**
+ * Helper to check if response has error
+ */
+function hasError(response) {
+    return response.error !== undefined;
+}
+/**
+ * Helper to check if response has data
+ */
+function hasData(response) {
+    return response.data !== undefined;
+}
+/**
+ * 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 CoreMemoryClient {
+    constructor(config) {
+        this.config = {
+            timeout: 30000,
+            ...config
+        };
+        this.baseHeaders = {
+            'Content-Type': 'application/json',
+            'User-Agent': '@lanonasis/memory-client/2.0.0',
+            'X-Project-Scope': 'lanonasis-maas', // Required by backend auth middleware
+            ...config.headers
+        };
+        // Set authentication headers
+        if (config.authToken) {
+            this.baseHeaders['Authorization'] = `Bearer ${config.authToken}`;
+        }
+        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 with retry support
+     */
+    async request(endpoint, options = {}) {
+        const startTime = Date.now();
+        const maxRetries = this.config.retry?.maxRetries ?? 3;
+        const baseDelay = this.config.retry?.retryDelay ?? 1000;
+        const backoff = this.config.retry?.backoff ?? 'exponential';
+        // 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', '')
+            : this.config.apiUrl;
+        const url = `${baseUrl}/api/v1${endpoint}`;
+        let lastError;
+        let attempt = 0;
+        while (attempt <= maxRetries) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+                const response = await fetch(url, {
+                    headers: { ...this.baseHeaders, ...options.headers },
+                    signal: controller.signal,
+                    ...options,
+                });
+                clearTimeout(timeoutId);
+                let data;
+                const contentType = response.headers.get('content-type');
+                if (contentType && contentType.includes('application/json')) {
+                    data = await response.json();
+                }
+                else {
+                    data = await response.text();
+                }
+                if (!response.ok) {
+                    const error = createErrorFromResponse(response.status, response.statusText, data);
+                    // Only retry on retryable errors (5xx, 429, 408)
+                    if (isRetryableError(response.status) && attempt < maxRetries) {
+                        lastError = error;
+                        const delay = calculateRetryDelay(attempt, baseDelay, backoff);
+                        await sleep(delay);
+                        attempt++;
+                        continue;
+                    }
+                    // Call onError hook if provided
+                    if (this.config.onError) {
+                        try {
+                            this.config.onError(error);
+                        }
+                        catch (hookError) {
+                            console.warn('onError hook error:', hookError);
+                        }
+                    }
+                    return { error, meta: { duration: Date.now() - startTime, retries: attempt } };
+                }
+                // 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, meta: { duration: Date.now() - startTime, retries: attempt } };
+            }
+            catch (error) {
+                if (error instanceof Error && error.name === 'AbortError') {
+                    const timeoutError = createErrorResponse('Request timeout', 'TIMEOUT_ERROR', 408);
+                    // Retry on timeout
+                    if (attempt < maxRetries) {
+                        lastError = timeoutError;
+                        const delay = calculateRetryDelay(attempt, baseDelay, backoff);
+                        await sleep(delay);
+                        attempt++;
+                        continue;
+                    }
+                    if (this.config.onError) {
+                        try {
+                            this.config.onError(timeoutError);
+                        }
+                        catch (hookError) {
+                            console.warn('onError hook error:', hookError);
+                        }
+                    }
+                    return { error: timeoutError, meta: { duration: Date.now() - startTime, retries: attempt } };
+                }
+                const networkError = createErrorResponse(error instanceof Error ? error.message : 'Network error', 'NETWORK_ERROR');
+                // Retry on network errors
+                if (attempt < maxRetries) {
+                    lastError = networkError;
+                    const delay = calculateRetryDelay(attempt, baseDelay, backoff);
+                    await sleep(delay);
+                    attempt++;
+                    continue;
+                }
+                if (this.config.onError) {
+                    try {
+                        this.config.onError(networkError);
+                    }
+                    catch (hookError) {
+                        console.warn('onError hook error:', hookError);
+                    }
+                }
+                return { error: networkError, meta: { duration: Date.now() - startTime, retries: attempt } };
+            }
+        }
+        // Should never reach here, but handle it gracefully
+        return {
+            error: lastError ?? createErrorResponse('Max retries exceeded', 'API_ERROR'),
+            meta: { duration: Date.now() - startTime, retries: attempt }
+        };
+    }
+    /**
+     * Validate input using Zod schema and return validation error if invalid
+     */
+    validateInput(schema, data) {
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            // Extract error details from Zod error
+            const zodError = result.error;
+            const details = zodError?.issues?.map(issue => ({
+                field: issue.path.map(String).join('.'),
+                message: issue.message
+            })) ?? [];
+            return {
+                error: createErrorResponse('Validation failed', 'VALIDATION_ERROR', 400, details)
+            };
+        }
+        return null;
+    }
+    /**
+     * Test the API connection and authentication
+     */
+    async healthCheck() {
+        return this.request('/health');
+    }
+    // Memory Operations
+    /**
+     * Create a new memory with validation
+     */
+    async createMemory(memory) {
+        // Validate input before making request
+        const validationError = this.validateInput(createMemorySchema, memory);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        const enrichedMemory = this.enrichWithOrgContext(memory);
+        return this.request('/memory', {
+            method: 'POST',
+            body: JSON.stringify(enrichedMemory)
+        });
+    }
+    /**
+     * Get a memory by ID
+     */
+    async getMemory(id) {
+        return this.request(`/memory/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Update an existing memory with validation
+     */
+    async updateMemory(id, updates) {
+        // Validate input before making request
+        const validationError = this.validateInput(updateMemorySchema, updates);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        return this.request(`/memory/${encodeURIComponent(id)}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates)
+        });
+    }
+    /**
+     * Delete a memory
+     */
+    async deleteMemory(id) {
+        return this.request(`/memory/${encodeURIComponent(id)}`, {
+            method: 'DELETE'
+        });
+    }
+    /**
+     * List memories with optional filtering and pagination
+     */
+    async listMemories(options = {}) {
+        const params = new URLSearchParams();
+        Object.entries(options).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                if (Array.isArray(value)) {
+                    params.append(key, value.join(','));
+                }
+                else {
+                    params.append(key, String(value));
+                }
+            }
+        });
+        const queryString = params.toString();
+        const endpoint = queryString ? `/memory?${queryString}` : '/memory';
+        return this.request(endpoint);
+    }
+    /**
+     * Search memories using semantic search with validation
+     */
+    async searchMemories(request) {
+        // Validate input before making request
+        const validationError = this.validateInput(searchMemorySchema, request);
+        if (validationError) {
+            // Return error response (data will be undefined, only error is set)
+            return { error: validationError.error };
+        }
+        const enrichedRequest = this.enrichWithOrgContext(request);
+        return this.request('/memory/search', {
+            method: 'POST',
+            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(enrichedRequest)
+        });
+    }
+    // Topic Operations
+    /**
+     * Create a new topic with validation
+     */
+    async createTopic(topic) {
+        // Validate input before making request
+        const validationError = this.validateInput(createTopicSchema, topic);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        const enrichedTopic = this.enrichWithOrgContext(topic);
+        return this.request('/topics', {
+            method: 'POST',
+            body: JSON.stringify(enrichedTopic)
+        });
+    }
+    /**
+     * Get all topics
+     */
+    async getTopics() {
+        return this.request('/topics');
+    }
+    /**
+     * Get a topic by ID
+     */
+    async getTopic(id) {
+        return this.request(`/topics/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Update a topic
+     */
+    async updateTopic(id, updates) {
+        return this.request(`/topics/${encodeURIComponent(id)}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates)
+        });
+    }
+    /**
+     * Delete a topic
+     */
+    async deleteTopic(id) {
+        return this.request(`/topics/${encodeURIComponent(id)}`, {
+            method: 'DELETE'
+        });
+    }
+    /**
+     * Get user memory statistics
+     */
+    async getMemoryStats() {
+        return this.request('/memory/stats');
+    }
+    // ========================================
+    // Intelligence Features (v2.0)
+    // ========================================
+    /**
+     * Create a memory with preprocessing options (chunking, intelligence extraction)
+     *
+     * @example
+     * ```typescript
+     * const result = await client.createMemoryWithPreprocessing({
+     *   title: 'Auth System Docs',
+     *   content: 'Long content...',
+     *   memory_type: 'knowledge',
+     *   preprocessing: {
+     *     chunking: { strategy: 'semantic', maxChunkSize: 1000 },
+     *     extractMetadata: true
+     *   }
+     * });
+     * ```
+     */
+    async createMemoryWithPreprocessing(memory) {
+        // Validate base memory fields
+        const validationError = this.validateInput(createMemorySchema, memory);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        const enrichedMemory = this.enrichWithOrgContext(memory);
+        return this.request('/memory', {
+            method: 'POST',
+            body: JSON.stringify(enrichedMemory)
+        });
+    }
+    /**
+     * Update a memory with re-chunking and embedding regeneration
+     *
+     * @example
+     * ```typescript
+     * const result = await client.updateMemoryWithPreprocessing('mem_123', {
+     *   content: 'Updated content...',
+     *   rechunk: true,
+     *   regenerate_embedding: true
+     * });
+     * ```
+     */
+    async updateMemoryWithPreprocessing(id, updates) {
+        const validationError = this.validateInput(updateMemorySchema, updates);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        return this.request(`/memory/${encodeURIComponent(id)}`, {
+            method: 'PUT',
+            body: JSON.stringify(updates)
+        });
+    }
+    /**
+     * Enhanced semantic search with hybrid mode (vector + text)
+     *
+     * @example
+     * ```typescript
+     * const result = await client.enhancedSearch({
+     *   query: 'authentication flow',
+     *   search_mode: 'hybrid',
+     *   filters: { tags: ['auth'], project_id: 'proj_123' },
+     *   include_chunks: true
+     * });
+     * ```
+     */
+    async enhancedSearch(request) {
+        const validationError = this.validateInput(enhancedSearchSchema, request);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        const enrichedRequest = this.enrichWithOrgContext(request);
+        return this.request('/memory/search', {
+            method: 'POST',
+            body: JSON.stringify(enrichedRequest)
+        });
+    }
+    // ========================================
+    // Analytics Operations
+    // ========================================
+    /**
+     * Get search analytics data
+     *
+     * @example
+     * ```typescript
+     * const analytics = await client.getSearchAnalytics({
+     *   from: '2025-01-01',
+     *   to: '2025-12-31',
+     *   group_by: 'day'
+     * });
+     * ```
+     */
+    async getSearchAnalytics(options = {}) {
+        const validationError = this.validateInput(analyticsDateRangeSchema, options);
+        if (validationError) {
+            return { error: validationError.error };
+        }
+        const params = new URLSearchParams();
+        if (options.from)
+            params.append('from', options.from);
+        if (options.to)
+            params.append('to', options.to);
+        if (options.group_by)
+            params.append('group_by', options.group_by);
+        const queryString = params.toString();
+        const endpoint = queryString ? `/analytics/search?${queryString}` : '/analytics/search';
+        return this.request(endpoint);
+    }
+    /**
+     * Get memory access patterns
+     *
+     * @example
+     * ```typescript
+     * const patterns = await client.getAccessPatterns({
+     *   from: '2025-01-01',
+     *   to: '2025-12-31'
+     * });
+     * console.log(patterns.data?.most_accessed);
+     * ```
+     */
+    async getAccessPatterns(options = {}) {
+        const params = new URLSearchParams();
+        if (options.from)
+            params.append('from', options.from);
+        if (options.to)
+            params.append('to', options.to);
+        const queryString = params.toString();
+        const endpoint = queryString ? `/analytics/access?${queryString}` : '/analytics/access';
+        return this.request(endpoint);
+    }
+    /**
+     * Get extended memory statistics with storage and activity metrics
+     *
+     * @example
+     * ```typescript
+     * const stats = await client.getExtendedStats();
+     * console.log(`Total chunks: ${stats.data?.storage.total_chunks}`);
+     * console.log(`Created today: ${stats.data?.activity.created_today}`);
+     * ```
+     */
+    async getExtendedStats() {
+        return this.request('/analytics/stats');
+    }
+    /**
+     * Get topic with its memories
+     *
+     * @example
+     * ```typescript
+     * const topic = await client.getTopicWithMemories('topic_123');
+     * console.log(topic.data?.memories);
+     * ```
+     */
+    async getTopicWithMemories(topicId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        if (options.offset)
+            params.append('offset', String(options.offset));
+        const queryString = params.toString();
+        const endpoint = queryString
+            ? `/topics/${encodeURIComponent(topicId)}/memories?${queryString}`
+            : `/topics/${encodeURIComponent(topicId)}/memories`;
+        return this.request(endpoint);
+    }
+    /**
+     * Get topics in hierarchical structure
+     *
+     * @example
+     * ```typescript
+     * const topics = await client.getTopicsHierarchy();
+     * // Returns nested topic tree with children
+     * ```
+     */
+    async getTopicsHierarchy() {
+        return this.request('/topics?include_hierarchy=true');
+    }
+    // Utility Methods
+    /**
+     * Update authentication token
+     */
+    setAuthToken(token) {
+        this.baseHeaders['Authorization'] = `Bearer ${token}`;
+        delete this.baseHeaders['X-API-Key'];
+    }
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey) {
+        this.baseHeaders['X-API-Key'] = apiKey;
+        delete this.baseHeaders['Authorization'];
+    }
+    /**
+     * Clear authentication
+     */
+    clearAuth() {
+        delete this.baseHeaders['Authorization'];
+        delete this.baseHeaders['X-API-Key'];
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        if (updates.headers) {
+            this.baseHeaders = { ...this.baseHeaders, ...updates.headers };
+        }
+    }
+    /**
+     * Get current configuration (excluding sensitive data)
+     */
+    getConfig() {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { apiKey, authToken, ...safeConfig } = this.config;
+        return safeConfig;
+    }
+}
+/**
+ * Factory function to create a new Core Memory Client instance
+ */
+function createMemoryClient(config) {
+    return new CoreMemoryClient(config);
+}
+
+/**
+ * Error handling for Memory Client
+ * Browser-safe, no Node.js dependencies
+ */
+/**
+ * Standardized error codes for programmatic error handling
+ */
+const ERROR_CODES = [
+    'API_ERROR',
+    'AUTH_ERROR',
+    'VALIDATION_ERROR',
+    'TIMEOUT_ERROR',
+    'RATE_LIMIT_ERROR',
+    'NOT_FOUND',
+    'NETWORK_ERROR',
+    'FORBIDDEN',
+    'CONFLICT',
+    'SERVER_ERROR'
+];
+/**
+ * Type guard to check if an object is an ApiErrorResponse
+ */
+function isApiErrorResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'code' in value &&
+        'message' in value &&
+        typeof value.code === 'string' &&
+        typeof value.message === 'string');
+}
+/**
+ * Base error class for Memory Client errors
+ */
+class MemoryClientError extends Error {
+    constructor(message, code = 'API_ERROR', 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);
+        }
+    }
+    /**
+     * Convert to ApiErrorResponse for consistent API responses
+     */
+    toResponse() {
+        return {
+            code: this.code,
+            message: this.message,
+            statusCode: this.statusCode,
+            details: this.details,
+            timestamp: new Date().toISOString()
+        };
+    }
+}
+/**
+ * Network/API error
+ */
+class ApiError extends MemoryClientError {
+    constructor(message, statusCode, details) {
+        super(message, 'API_ERROR', statusCode, details);
+        this.name = 'ApiError';
+    }
+    /**
+     * Create from an HTTP response
+     */
+    static fromResponse(status, statusText, body) {
+        let message = `HTTP ${status}: ${statusText}`;
+        let details = undefined;
+        if (body && typeof body === 'object') {
+            const bodyObj = body;
+            if (typeof bodyObj.error === 'string') {
+                message = bodyObj.error;
+            }
+            else if (typeof bodyObj.message === 'string') {
+                message = bodyObj.message;
+            }
+            if (bodyObj.details) {
+                details = bodyObj.details;
+            }
+        }
+        return new ApiError(message, status, details);
+    }
+}
+/**
+ * Authentication error
+ */
+class AuthenticationError extends MemoryClientError {
+    constructor(message = 'Authentication required') {
+        super(message, 'AUTH_ERROR', 401);
+        this.name = 'AuthenticationError';
+    }
+}
+/**
+ * Validation error with field-level details
+ */
+class ValidationError extends MemoryClientError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', 400, details);
+        this.name = 'ValidationError';
+        // Parse validation details into field errors
+        this.validationErrors = [];
+        if (Array.isArray(details)) {
+            this.validationErrors = details.filter((item) => typeof item === 'object' &&
+                item !== null &&
+                typeof item.field === 'string' &&
+                typeof item.message === 'string');
+        }
+    }
+    /**
+     * Create from Zod error
+     */
+    static fromZodError(error) {
+        const details = error.issues.map(issue => ({
+            field: issue.path.join('.'),
+            message: issue.message
+        }));
+        return new ValidationError('Validation failed', details);
+    }
+}
+/**
+ * Timeout error
+ */
+class TimeoutError extends MemoryClientError {
+    constructor(message = 'Request timeout') {
+        super(message, 'TIMEOUT_ERROR', 408);
+        this.name = 'TimeoutError';
+    }
+}
+/**
+ * Rate limit error with retry-after info
+ */
+class RateLimitError extends MemoryClientError {
+    constructor(message = 'Rate limit exceeded', retryAfter) {
+        super(message, 'RATE_LIMIT_ERROR', 429, { retryAfter });
+        this.name = 'RateLimitError';
+        this.retryAfter = retryAfter;
+    }
+}
+/**
+ * Not found error
+ */
+class NotFoundError extends MemoryClientError {
+    constructor(resource) {
+        super(`${resource} not found`, 'NOT_FOUND', 404);
+        this.name = 'NotFoundError';
+        this.resource = resource;
+    }
+}
+/**
+ * Network error (no response received)
+ */
+class NetworkError extends MemoryClientError {
+    constructor(message = 'Network error') {
+        super(message, 'NETWORK_ERROR');
+        this.name = 'NetworkError';
+    }
+}
+/**
+ * Server error (5xx responses)
+ */
+class ServerError extends MemoryClientError {
+    constructor(message, statusCode = 500) {
+        super(message, 'SERVER_ERROR', statusCode);
+        this.name = 'ServerError';
+    }
+}
+/**
+ * Create appropriate error class from status code
+ */
+function createErrorFromStatus(status, message, details) {
+    switch (status) {
+        case 400:
+            return new ValidationError(message, details);
+        case 401:
+            return new AuthenticationError(message);
+        case 404:
+            return new NotFoundError(message);
+        case 408:
+            return new TimeoutError(message);
+        case 429:
+            return new RateLimitError(message);
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            return new ServerError(message, status);
+        default:
+            return new ApiError(message, status, details);
+    }
+}
+
+/**
+ * @lanonasis/memory-client
+ *
+ * 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';
+ * ```
+ */
+// ========================================
+// Internal Imports (for use in this file)
+// ========================================
+// ========================================
+// Constants
+// ========================================
+const VERSION = '2.0.0';
+const CLIENT_NAME = '@lanonasis/memory-client';
+// ========================================
+// Environment Detection
+// ========================================
+const isBrowser = typeof window !== 'undefined';
+const isNode = typeof globalThis !== 'undefined' && 'process' in globalThis && globalThis.process?.versions?.node;
+const isEdge = !isBrowser && !isNode;
+/**
+ * Get the current runtime environment
+ */
+function getEnvironment() {
+    if (isBrowser)
+        return 'browser';
+    if (isNode)
+        return 'node';
+    return 'edge';
+}
+/**
+ * Auto-detecting client factory - "Drop In and Sleep" architecture
+ *
+ * Automatically detects the runtime environment and returns the appropriate client:
+ * - Browser/Edge: Returns CoreMemoryClient (lightweight, browser-safe)
+ * - Node.js: Returns EnhancedMemoryClient (with CLI/MCP support)
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@lanonasis/memory-client';
+ *
+ * // Works in any environment!
+ * const client = await createClient({
+ *   apiUrl: 'https://api.lanonasis.com',
+ *   apiKey: 'your-key'
+ * });
+ *
+ * const memories = await client.listMemories();
+ * ```
+ */
+async function createClient(config) {
+    const environment = getEnvironment();
+    if (environment === 'node') {
+        try {
+            // Dynamic import for Node.js client to avoid bundling in browser
+            const { createNodeMemoryClient } = await Promise.resolve().then(function () { return index; });
+            return await createNodeMemoryClient({
+                ...config,
+                preferCLI: config.preferCLI ?? true,
+                enableMCP: config.enableMCP ?? true
+            });
+        }
+        catch {
+            // Fallback to core client if Node module fails to load
+            console.warn('Failed to load Node.js client, falling back to core client');
+        }
+    }
+    // Browser, Edge, or fallback
+    const clientConfig = {
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        authToken: config.authToken,
+        organizationId: config.organizationId,
+        timeout: config.timeout ?? (environment === 'edge' ? 5000 : 30000),
+        headers: config.headers,
+        retry: config.retry
+    };
+    return createMemoryClient(clientConfig);
+}
+// ========================================
+// Default Configurations
+// ========================================
+const defaultConfigs = {
+    development: {
+        apiUrl: 'http://localhost:3001',
+        timeout: 30000,
+    },
+    production: {
+        apiUrl: 'https://api.lanonasis.com',
+        timeout: 15000,
+    },
+    edge: {
+        apiUrl: 'https://api.lanonasis.com',
+        timeout: 5000,
+    }
+};
+// 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
+ */
+
+/**
+ * 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
+ *
+ * IMPORTANT: This file imports Node.js modules and should only be used in Node.js environments
+ */
+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 parseResult = safeJsonParse(authOutput);
+                if (parseResult.success) {
+                    authenticated = parseResult.data.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: createErrorResponse('CLI not available', 'API_ERROR') };
+        }
+        if (!cliInfo.authenticated) {
+            return { error: createErrorResponse('CLI not authenticated. Run: onasis login', 'AUTH_ERROR', 401) };
+        }
+        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') {
+                const parseResult = safeJsonParse(stdout);
+                if (parseResult.success) {
+                    return { data: parseResult.data };
+                }
+                return { error: createErrorResponse(parseResult.error, 'VALIDATION_ERROR', 400) };
+            }
+            return { data: stdout };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timeout')) {
+                return { error: createErrorResponse('CLI command timeout', 'TIMEOUT_ERROR', 408) };
+            }
+            return {
+                error: createErrorResponse(error instanceof Error ? error.message : 'CLI command failed', 'API_ERROR')
+            };
+        }
+    }
+    /**
+     * 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: createErrorResponse('MCP not available via CLI', 'API_ERROR') };
+        }
+        return this.executeCLICommand('mcp status');
+    }
+    async listMCPTools() {
+        const cliInfo = await this.detectCLI();
+        if (!cliInfo.mcpAvailable) {
+            return { error: createErrorResponse('MCP not available via CLI', 'API_ERROR') };
+        }
+        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
+ *
+ * IMPORTANT: This file uses Node.js-specific features (process.env) and should only be used in Node.js environments
+ */
+/**
+ * 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;
+        // Merge config with defaults, ensuring all required fields are present
+        // Spread config first, then apply defaults only for undefined values
+        const mergedConfig = {
+            ...config,
+            preferCLI: config.preferCLI ?? true,
+            enableMCP: config.enableMCP ?? true,
+            cliDetectionTimeout: config.cliDetectionTimeout ?? 5000,
+            fallbackToAPI: config.fallbackToAPI ?? true,
+            minCLIVersion: config.minCLIVersion ?? '1.5.2',
+            verbose: config.verbose ?? false,
+            timeout: config.timeout ?? 30000,
+            apiUrl: config.apiUrl || 'https://api.lanonasis.com',
+            apiKey: config.apiKey || process.env.LANONASIS_API_KEY || '',
+            authToken: config.authToken || '',
+            headers: config.headers || {}
+        };
+        this.config = mergedConfig;
+        this.directClient = new CoreMemoryClient(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();
+        }
+        if (!this.capabilities) {
+            this.capabilities = this.createDefaultCapabilities();
+        }
+        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: createErrorResponse(error instanceof Error ? error.message : `CLI ${operation} failed`, 'API_ERROR'),
+                    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: createErrorResponse(error instanceof Error ? error.message : 'Auth status check failed', 'API_ERROR'),
+                source: 'cli',
+                mcpUsed: false
+            };
+        }
+    }
+    /**
+     * Get MCP status when available
+     */
+    async getMCPStatus() {
+        const capabilities = await this.getCapabilities();
+        if (!capabilities.mcpSupport) {
+            return {
+                error: createErrorResponse('MCP not available', 'API_ERROR'),
+                source: 'cli',
+                mcpUsed: false
+            };
+        }
+        try {
+            const result = await this.cliIntegration.getMCPStatus();
+            return { ...result, source: 'cli', mcpUsed: true };
+        }
+        catch (error) {
+            return {
+                error: createErrorResponse(error instanceof Error ? error.message : 'MCP status check failed', 'API_ERROR'),
+                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 createNodeMemoryClient(config) {
+    const client = new EnhancedMemoryClient(config);
+    await client.initialize();
+    return client;
+}
+
+/**
+ * @lanonasis/memory-client/node
+ *
+ * Node.js-enhanced client with CLI integration
+ * ONLY import this in Node.js environments
+ *
+ * Provides intelligent CLI detection and MCP channel utilization
+ * when @lanonasis/cli v1.5.2+ is available
+ */
+// Enhanced client with CLI support
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CLIIntegration: CLIIntegration,
+    EnhancedMemoryClient: EnhancedMemoryClient,
+    createNodeMemoryClient: createNodeMemoryClient
+});
+
+exports.ApiError = ApiError;
+exports.AuthenticationError = AuthenticationError;
+exports.CHUNKING_STRATEGIES = CHUNKING_STRATEGIES;
+exports.CLIENT_NAME = CLIENT_NAME;
+exports.CONTENT_TYPES = CONTENT_TYPES;
+exports.CoreMemoryClient = CoreMemoryClient;
+exports.ERROR_CODES = ERROR_CODES;
+exports.MEMORY_STATUSES = MEMORY_STATUSES;
+exports.MEMORY_TYPES = MEMORY_TYPES;
+exports.MemoryClient = CoreMemoryClient;
+exports.MemoryClientError = MemoryClientError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.SEARCH_MODES = SEARCH_MODES;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.VERSION = VERSION;
+exports.ValidationError = ValidationError;
+exports.analyticsDateRangeSchema = analyticsDateRangeSchema;
+exports.calculateRetryDelay = calculateRetryDelay;
+exports.createClient = createClient;
+exports.createErrorFromStatus = createErrorFromStatus;
+exports.createErrorResponse = createErrorResponse;
+exports.createMemoryClient = createMemoryClient;
+exports.createMemorySchema = createMemorySchema;
+exports.createTopicSchema = createTopicSchema;
+exports.defaultConfigs = defaultConfigs;
+exports.enhancedSearchSchema = enhancedSearchSchema;
+exports.getEnvironment = getEnvironment;
+exports.hasData = hasData;
+exports.hasError = hasError;
+exports.httpStatusToErrorCode = httpStatusToErrorCode;
+exports.isApiErrorResponse = isApiErrorResponse;
+exports.isBrowser = isBrowser;
+exports.isEdge = isEdge;
+exports.isNode = isNode;
+exports.isRetryableError = isRetryableError;
+exports.preprocessingOptionsSchema = preprocessingOptionsSchema;
+exports.safeJsonParse = safeJsonParse;
+exports.searchMemorySchema = searchMemorySchema;
+exports.updateMemorySchema = updateMemorySchema;
+//# sourceMappingURL=index.cjs.map