@lanonasis/memory-client 1.0.1 → 2.1.0

package/dist/index.d.ts

@@ -142,32 +142,489 @@ type CreateMemoryRequest = z.infer<typeof createMemorySchema>;
 type UpdateMemoryRequest = z.infer<typeof updateMemorySchema>;
 type SearchMemoryRequest = z.infer<typeof searchMemorySchema>;
 type CreateTopicRequest = z.infer<typeof createTopicSchema>;
+/**
+ * Chunking strategies for content preprocessing
+ */
+declare const CHUNKING_STRATEGIES: readonly ["semantic", "fixed-size", "paragraph", "sentence", "code-block"];
+type ChunkingStrategy = typeof CHUNKING_STRATEGIES[number];
+/**
+ * Content types detected or specified
+ */
+declare const CONTENT_TYPES: readonly ["text", "code", "markdown", "json", "yaml"];
+type ContentType = typeof CONTENT_TYPES[number];
+/**
+ * A chunk of content from a memory entry
+ */
+interface ContentChunk {
+    index: number;
+    content: string;
+    startChar: number;
+    endChar: number;
+    tokens: number;
+    metadata?: {
+        type: 'paragraph' | 'sentence' | 'code' | 'section';
+        isComplete: boolean;
+    };
+}
+/**
+ * Extracted intelligence from memory content
+ */
+interface MemoryIntelligence {
+    entities: string[];
+    keywords: string[];
+    language: string;
+    topics?: string[];
+    sentiment?: 'positive' | 'neutral' | 'negative';
+    complexity?: 'low' | 'medium' | 'high';
+}
+/**
+ * Extended metadata with intelligence features
+ */
+interface IntelligentMetadata extends Record<string, unknown> {
+    chunks?: ContentChunk[];
+    total_chunks?: number;
+    chunking_strategy?: ChunkingStrategy;
+    last_rechunked_at?: string;
+    intelligence?: MemoryIntelligence;
+    content_type?: ContentType;
+    language?: string;
+    tokens?: number;
+    source?: string;
+    priority?: 'high' | 'medium' | 'low';
+}
+/**
+ * Preprocessing options for memory creation/update
+ */
+interface PreprocessingOptions {
+    chunking?: {
+        strategy?: ChunkingStrategy;
+        maxChunkSize?: number;
+        overlap?: number;
+    };
+    cleanContent?: boolean;
+    extractMetadata?: boolean;
+}
+/**
+ * Extended create memory request with preprocessing
+ */
+interface CreateMemoryWithPreprocessingRequest extends CreateMemoryRequest {
+    preprocessing?: PreprocessingOptions;
+    metadata?: IntelligentMetadata;
+}
+/**
+ * Extended update memory request with re-chunking
+ */
+interface UpdateMemoryWithPreprocessingRequest extends UpdateMemoryRequest {
+    rechunk?: boolean;
+    regenerate_embedding?: boolean;
+}
+/**
+ * Search modes for memory queries
+ */
+declare const SEARCH_MODES: readonly ["vector", "text", "hybrid"];
+type SearchMode = typeof SEARCH_MODES[number];
+/**
+ * A matching chunk from search results
+ */
+interface MatchingChunk {
+    index: number;
+    content: string;
+    similarity: number;
+}
+/**
+ * Enhanced search filters
+ */
+interface SearchFilters {
+    tags?: string[];
+    project_id?: string;
+    topic_id?: string;
+    date_range?: {
+        from?: string;
+        to?: string;
+    };
+}
+/**
+ * Enhanced search request with hybrid mode
+ */
+interface EnhancedSearchRequest {
+    query: string;
+    type?: MemoryType;
+    threshold?: number;
+    limit?: number;
+    search_mode?: SearchMode;
+    filters?: SearchFilters;
+    include_chunks?: boolean;
+}
+/**
+ * Enhanced search result with chunk matching
+ */
+interface EnhancedMemorySearchResult extends MemorySearchResult {
+    text_rank?: number;
+    combined_score?: number;
+    matching_chunks?: MatchingChunk[];
+}
+/**
+ * Enhanced search response
+ */
+interface EnhancedSearchResponse {
+    results: EnhancedMemorySearchResult[];
+    total: number;
+    query: string;
+    search_mode: SearchMode;
+    threshold: number;
+    execution_time_ms: number;
+}
+/**
+ * Search analytics data point
+ */
+interface SearchAnalyticsDataPoint {
+    date: string;
+    searches: number;
+    avg_results: number;
+    avg_time_ms: number;
+}
+/**
+ * Popular query entry
+ */
+interface PopularQuery {
+    query: string;
+    count: number;
+    avg_results: number;
+}
+/**
+ * Search analytics response
+ */
+interface SearchAnalytics {
+    total_searches: number;
+    avg_results_count: number;
+    avg_execution_time_ms: number;
+    search_types: {
+        vector: number;
+        text: number;
+        hybrid: number;
+    };
+    by_date: SearchAnalyticsDataPoint[];
+    popular_queries: PopularQuery[];
+}
+/**
+ * Most accessed memory entry
+ */
+interface MostAccessedMemory {
+    memory_id: string;
+    title: string;
+    access_count: number;
+    last_accessed: string;
+}
+/**
+ * Hourly access data
+ */
+interface HourlyAccess {
+    hour: number;
+    count: number;
+}
+/**
+ * Access patterns response
+ */
+interface AccessPatterns {
+    total_accesses: number;
+    by_type: {
+        read: number;
+        update: number;
+        delete: number;
+    };
+    by_method: {
+        api: number;
+        search: number;
+        direct: number;
+    };
+    most_accessed: MostAccessedMemory[];
+    access_by_hour: HourlyAccess[];
+}
+/**
+ * Project memory count
+ */
+interface ProjectMemoryCount {
+    project_id: string;
+    project_name: string;
+    count: number;
+}
+/**
+ * Tag count entry
+ */
+interface TagCount {
+    tag: string;
+    count: number;
+}
+/**
+ * Extended memory statistics
+ */
+interface ExtendedMemoryStats {
+    total_memories: number;
+    by_type: Record<MemoryType, number>;
+    by_project: ProjectMemoryCount[];
+    storage: {
+        total_size_mb: number;
+        avg_memory_size_kb: number;
+        total_chunks: number;
+    };
+    activity: {
+        created_today: number;
+        updated_today: number;
+        searched_today: number;
+    };
+    top_tags: TagCount[];
+}
+/**
+ * Analytics date range filter
+ */
+interface AnalyticsDateRange {
+    from?: string;
+    to?: string;
+    group_by?: 'day' | 'week' | 'month';
+}
+declare const preprocessingOptionsSchema: z.ZodOptional<z.ZodObject<{
+    chunking: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodOptional<z.ZodEnum<{
+            semantic: "semantic";
+            "fixed-size": "fixed-size";
+            paragraph: "paragraph";
+            sentence: "sentence";
+            "code-block": "code-block";
+        }>>;
+        maxChunkSize: z.ZodOptional<z.ZodNumber>;
+        overlap: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    cleanContent: z.ZodOptional<z.ZodBoolean>;
+    extractMetadata: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+declare const enhancedSearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        context: "context";
+        project: "project";
+        knowledge: "knowledge";
+        reference: "reference";
+        personal: "personal";
+        workflow: "workflow";
+    }>>;
+    threshold: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    search_mode: z.ZodDefault<z.ZodEnum<{
+        text: "text";
+        vector: "vector";
+        hybrid: "hybrid";
+    }>>;
+    filters: z.ZodOptional<z.ZodObject<{
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        project_id: z.ZodOptional<z.ZodString>;
+        topic_id: z.ZodOptional<z.ZodString>;
+        date_range: z.ZodOptional<z.ZodObject<{
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    include_chunks: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const analyticsDateRangeSchema: z.ZodObject<{
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    group_by: z.ZodDefault<z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+    }>>;
+}, z.core.$strip>;
+
+/**
+ * Error handling for Memory Client
+ * Browser-safe, no Node.js dependencies
+ */
+/**
+ * Standardized error codes for programmatic error handling
+ */
+declare const ERROR_CODES: readonly ["API_ERROR", "AUTH_ERROR", "VALIDATION_ERROR", "TIMEOUT_ERROR", "RATE_LIMIT_ERROR", "NOT_FOUND", "NETWORK_ERROR", "FORBIDDEN", "CONFLICT", "SERVER_ERROR"];
+type ErrorCode = typeof ERROR_CODES[number];
+/**
+ * Structured API error response - replaces plain string errors
+ * Enables programmatic error handling with typed codes
+ */
+interface ApiErrorResponse {
+    /** Machine-readable error code for programmatic handling */
+    code: ErrorCode;
+    /** Human-readable error message */
+    message: string;
+    /** HTTP status code if from API response */
+    statusCode?: number;
+    /** Additional error details (validation errors, etc.) */
+    details?: unknown;
+    /** Request ID for debugging/support */
+    requestId?: string;
+    /** Timestamp when error occurred */
+    timestamp?: string;
+}
+/**
+ * Type guard to check if an object is an ApiErrorResponse
+ */
+declare function isApiErrorResponse(value: unknown): value is ApiErrorResponse;
+/**
+ * Base error class for Memory Client errors
+ */
+declare class MemoryClientError extends Error {
+    code: ErrorCode;
+    statusCode?: number | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code?: ErrorCode, statusCode?: number | undefined, details?: unknown | undefined);
+    /**
+     * Convert to ApiErrorResponse for consistent API responses
+     */
+    toResponse(): ApiErrorResponse;
+}
+/**
+ * Network/API error
+ */
+declare class ApiError extends MemoryClientError {
+    constructor(message: string, statusCode?: number, details?: unknown);
+    /**
+     * Create from an HTTP response
+     */
+    static fromResponse(status: number, statusText: string, body?: unknown): ApiError;
+}
+/**
+ * Authentication error
+ */
+declare class AuthenticationError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Validation error with field-level details
+ */
+declare class ValidationError extends MemoryClientError {
+    readonly validationErrors: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message: string, details?: unknown);
+    /**
+     * Create from Zod error
+     */
+    static fromZodError(error: {
+        issues: Array<{
+            path: (string | number)[];
+            message: string;
+        }>;
+    }): ValidationError;
+}
+/**
+ * Timeout error
+ */
+declare class TimeoutError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Rate limit error with retry-after info
+ */
+declare class RateLimitError extends MemoryClientError {
+    readonly retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+/**
+ * Not found error
+ */
+declare class NotFoundError extends MemoryClientError {
+    readonly resource: string;
+    constructor(resource: string);
+}
+/**
+ * Network error (no response received)
+ */
+declare class NetworkError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Server error (5xx responses)
+ */
+declare class ServerError extends MemoryClientError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Create appropriate error class from status code
+ */
+declare function createErrorFromStatus(status: number, message: string, details?: unknown): MemoryClientError;
+
+/**
+ * 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
+ */
 
 /**
  * Configuration options for the Memory Client
  */
-interface MemoryClientConfig {
+interface CoreMemoryClientConfig {
     /** API endpoint URL */
     apiUrl: string;
     /** API key for authentication */
     apiKey?: string;
     /** Bearer token for authentication (alternative to API key) */
     authToken?: string;
-    /** Request timeout in milliseconds */
+    /** Organization ID (optional - will be auto-resolved if not provided) */
+    organizationId?: string;
+    /** User ID (optional - used as fallback for organization ID) */
+    userId?: string;
+    /** Request timeout in milliseconds (default: 30000) */
     timeout?: number;
-    /** Enable gateway mode for enhanced performance */
-    useGateway?: boolean;
     /** Custom headers to include with requests */
     headers?: Record<string, string>;
+    /** Retry configuration */
+    retry?: {
+        maxRetries?: number;
+        retryDelay?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+    /** Cache configuration (browser only) */
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+    };
+    /** Called when an error occurs */
+    onError?: (error: ApiErrorResponse) => void;
+    /** Called before each request */
+    onRequest?: (endpoint: string) => void;
+    /** Called after each response */
+    onResponse?: (endpoint: string, duration: number) => void;
 }
 /**
- * Standard API response wrapper
+ * Standard API response wrapper with typed errors
+ * Replaces string errors with structured ApiErrorResponse
  */
 interface ApiResponse<T> {
     data?: T;
-    error?: string;
+    /** Structured error response for programmatic handling */
+    error?: ApiErrorResponse;
+    /** Optional success message */
     message?: string;
+    /** Request metadata */
+    meta?: {
+        requestId?: string;
+        duration?: number;
+        retries?: number;
+    };
 }
+/**
+ * Helper to check if response has error
+ */
+declare function hasError<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    error: ApiErrorResponse;
+};
+/**
+ * Helper to check if response has data
+ */
+declare function hasData<T>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    data: T;
+};
 /**
  * Paginated response for list operations
  */
@@ -181,16 +638,28 @@ interface PaginatedResponse<T> {
     };
 }
 /**
- * Memory Client class for interacting with the Memory as a Service API
+ * 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.)
  */
-declare class MemoryClient {
+declare class CoreMemoryClient {
     private config;
     private baseHeaders;
-    constructor(config: MemoryClientConfig);
+    constructor(config: CoreMemoryClientConfig);
     /**
-     * Make an HTTP request to the API
+     * Enrich request body with organization context if configured
+     * This ensures the API has the organization_id even if not in auth token
+     */
+    private enrichWithOrgContext;
+    /**
+     * Make an HTTP request to the API with retry support
      */
     private request;
+    /**
+     * Validate input using Zod schema and return validation error if invalid
+     */
+    private validateInput;
     /**
      * Test the API connection and authentication
      */
@@ -199,7 +668,7 @@ declare class MemoryClient {
         timestamp: string;
     }>>;
     /**
-     * Create a new memory
+     * Create a new memory with validation
      */
     createMemory(memory: CreateMemoryRequest): Promise<ApiResponse<MemoryEntry>>;
     /**
@@ -207,7 +676,7 @@ declare class MemoryClient {
      */
     getMemory(id: string): Promise<ApiResponse<MemoryEntry>>;
     /**
-     * Update an existing memory
+     * Update an existing memory with validation
      */
     updateMemory(id: string, updates: UpdateMemoryRequest): Promise<ApiResponse<MemoryEntry>>;
     /**
@@ -229,7 +698,7 @@ declare class MemoryClient {
         order?: 'asc' | 'desc';
     }): Promise<ApiResponse<PaginatedResponse<MemoryEntry>>>;
     /**
-     * Search memories using semantic search
+     * Search memories using semantic search with validation
      */
     searchMemories(request: SearchMemoryRequest): Promise<ApiResponse<{
         results: MemorySearchResult[];
@@ -244,7 +713,7 @@ declare class MemoryClient {
         failed_ids: string[];
     }>>;
     /**
-     * Create a new topic
+     * Create a new topic with validation
      */
     createTopic(topic: CreateTopicRequest): Promise<ApiResponse<MemoryTopic>>;
     /**
@@ -268,409 +737,291 @@ declare class MemoryClient {
      */
     getMemoryStats(): Promise<ApiResponse<UserMemoryStats>>;
     /**
-     * Update authentication token
+     * 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
+     *   }
+     * });
+     * ```
      */
-    setAuthToken(token: string): void;
+    createMemoryWithPreprocessing(memory: CreateMemoryWithPreprocessingRequest): Promise<ApiResponse<MemoryEntry>>;
     /**
-     * Update API key
+     * 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
+     * });
+     * ```
      */
-    setApiKey(apiKey: string): void;
+    updateMemoryWithPreprocessing(id: string, updates: UpdateMemoryWithPreprocessingRequest): Promise<ApiResponse<MemoryEntry>>;
     /**
-     * Clear authentication
+     * 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
+     * });
+     * ```
      */
-    clearAuth(): void;
+    enhancedSearch(request: EnhancedSearchRequest): Promise<ApiResponse<EnhancedSearchResponse>>;
     /**
-     * Update configuration
+     * Get search analytics data
+     *
+     * @example
+     * ```typescript
+     * const analytics = await client.getSearchAnalytics({
+     *   from: '2025-01-01',
+     *   to: '2025-12-31',
+     *   group_by: 'day'
+     * });
+     * ```
      */
-    updateConfig(updates: Partial<MemoryClientConfig>): void;
+    getSearchAnalytics(options?: AnalyticsDateRange): Promise<ApiResponse<SearchAnalytics>>;
     /**
-     * Get current configuration (excluding sensitive data)
+     * 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);
+     * ```
      */
-    getConfig(): Omit<MemoryClientConfig, 'apiKey' | 'authToken'>;
-}
-/**
- * Factory function to create a new Memory Client instance
- */
-declare function createMemoryClient(config: MemoryClientConfig): MemoryClient;
-
-/**
- * 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
- */
-
-interface CLIInfo {
-    available: boolean;
-    version?: string;
-    mcpAvailable?: boolean;
-    authenticated?: boolean;
-}
-interface CLIExecutionOptions {
-    timeout?: number;
-    verbose?: boolean;
-    outputFormat?: 'json' | 'table' | 'yaml';
-}
-interface CLICommand {
-    command: string;
-    args: string[];
-    options?: CLIExecutionOptions;
-}
-interface MCPChannel {
-    available: boolean;
-    version?: string;
-    capabilities?: string[];
-}
-interface CLICapabilities {
-    cliAvailable: boolean;
-    mcpSupport: boolean;
-    authenticated: boolean;
-    goldenContract: boolean;
-    version?: string;
-}
-type RoutingStrategy = 'cli-first' | 'api-first' | 'cli-only' | 'api-only' | 'auto';
-interface CLIAuthStatus {
-    authenticated: boolean;
-    user?: {
-        id?: string;
-        email?: string;
-        name?: string;
-        [key: string]: unknown;
-    };
-    scopes?: string[];
-    expiresAt?: string;
-    [key: string]: unknown;
-}
-interface CLIMCPStatus {
-    connected: boolean;
-    channel?: string;
-    endpoint?: string;
-    details?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-interface CLIMCPTool {
-    name: string;
-    title?: string;
-    description?: string;
-    [key: string]: unknown;
-}
-/**
- * CLI Detection and Integration Service
- */
-declare class CLIIntegration {
-    private cliInfo;
-    private detectionPromise;
-    /**
-     * Detect if CLI is available and get its capabilities
-     */
-    detectCLI(): Promise<CLIInfo>;
-    private performDetection;
-    /**
-     * Execute CLI command and return parsed JSON result
-     */
-    executeCLICommand<T = unknown>(command: string, options?: CLIExecutionOptions): Promise<ApiResponse<T>>;
+    getAccessPatterns(options?: AnalyticsDateRange): Promise<ApiResponse<AccessPatterns>>;
     /**
-     * Get preferred CLI command (onasis for Golden Contract, fallback to lanonasis)
+     * 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}`);
+     * ```
      */
-    private getPreferredCLICommand;
+    getExtendedStats(): Promise<ApiResponse<ExtendedMemoryStats>>;
     /**
-     * Memory operations via CLI
+     * Get topic with its memories
+     *
+     * @example
+     * ```typescript
+     * const topic = await client.getTopicWithMemories('topic_123');
+     * console.log(topic.data?.memories);
+     * ```
      */
-    createMemoryViaCLI(title: string, content: string, options?: {
-        memoryType?: string;
-        tags?: string[];
-        topicId?: string;
-    }): Promise<ApiResponse<MemoryEntry>>;
-    listMemoriesViaCLI(options?: {
-        limit?: number;
-        memoryType?: string;
-        tags?: string[];
-        sortBy?: string;
-    }): Promise<ApiResponse<PaginatedResponse<MemoryEntry>>>;
-    searchMemoriesViaCLI(query: string, options?: {
+    getTopicWithMemories(topicId: string, options?: {
         limit?: number;
-        memoryTypes?: string[];
+        offset?: number;
     }): Promise<ApiResponse<{
-        results: MemorySearchResult[];
-        total_results: number;
-        search_time_ms: number;
+        topic: MemoryTopic;
+        memories: MemoryEntry[];
+        total_memories: number;
+        subtopics: Array<{
+            id: string;
+            name: string;
+            memory_count: number;
+        }>;
     }>>;
     /**
-     * Health check via CLI
+     * Get topics in hierarchical structure
+     *
+     * @example
+     * ```typescript
+     * const topics = await client.getTopicsHierarchy();
+     * // Returns nested topic tree with children
+     * ```
      */
-    healthCheckViaCLI(): Promise<ApiResponse<{
-        status: string;
-        timestamp: string;
-    }>>;
+    getTopicsHierarchy(): Promise<ApiResponse<Array<MemoryTopic & {
+        children: MemoryTopic[];
+        memory_count: number;
+    }>>>;
     /**
-     * MCP-specific operations
+     * Update authentication token
      */
-    getMCPStatus(): Promise<ApiResponse<CLIMCPStatus>>;
-    listMCPTools(): Promise<ApiResponse<{
-        tools: CLIMCPTool[];
-    }>>;
+    setAuthToken(token: string): void;
     /**
-     * Authentication operations
+     * Update API key
      */
-    getAuthStatus(): Promise<ApiResponse<CLIAuthStatus>>;
+    setApiKey(apiKey: string): void;
     /**
-     * Check if specific CLI features are available
+     * Clear authentication
      */
-    getCapabilities(): Promise<{
-        cliAvailable: boolean;
-        version?: string;
-        mcpSupport: boolean;
-        authenticated: boolean;
-        goldenContract: boolean;
-    }>;
-    private isGoldenContractCompliant;
+    clearAuth(): void;
     /**
-     * Force refresh CLI detection
+     * Update configuration
      */
-    refresh(): Promise<CLIInfo>;
+    updateConfig(updates: Partial<CoreMemoryClientConfig>): void;
     /**
-     * Get cached CLI info without re-detection
+     * Get current configuration (excluding sensitive data)
      */
-    getCachedInfo(): CLIInfo | null;
+    getConfig(): Omit<CoreMemoryClientConfig, 'apiKey' | 'authToken'>;
 }
+/**
+ * Factory function to create a new Core Memory Client instance
+ */
+declare function createMemoryClient(config: CoreMemoryClientConfig): CoreMemoryClient;
 
 /**
- * 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
+ * Core Utilities for Memory Client
+ * Browser-safe, no Node.js dependencies
  */
 
-interface EnhancedMemoryClientConfig extends MemoryClientConfig {
-    /** Prefer CLI when available (default: true) */
-    preferCLI?: boolean;
-    /** Enable MCP channels when available (default: true) */
-    enableMCP?: boolean;
-    /** CLI detection timeout in ms (default: 5000) */
-    cliDetectionTimeout?: number;
-    /** Fallback to direct API on CLI failure (default: true) */
-    fallbackToAPI?: boolean;
-    /** Minimum CLI version required for Golden Contract compliance (default: 1.5.2) */
-    minCLIVersion?: string;
-    /** Enable verbose logging for troubleshooting (default: false) */
-    verbose?: boolean;
-}
-interface OperationResult<T> {
-    data?: T;
-    error?: string;
-    source: 'cli' | 'api';
-    mcpUsed?: boolean;
-}
 /**
- * Enhanced Memory Client with intelligent CLI/API routing
+ * Safe JSON parse result - discriminated union for type-safe error handling
  */
-declare class EnhancedMemoryClient {
-    private directClient;
-    private cliIntegration;
-    private config;
-    private capabilities;
-    private createDefaultCapabilities;
-    constructor(config: EnhancedMemoryClientConfig);
-    /**
-     * Initialize the client and detect capabilities
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get current capabilities
-     */
-    getCapabilities(): Promise<Awaited<ReturnType<CLIIntegration['getCapabilities']>>>;
-    /**
-     * Determine if operation should use CLI
-     */
-    private shouldUseCLI;
-    /**
-     * Execute operation with intelligent routing
-     */
-    private executeOperation;
-    /**
-     * Health check with intelligent routing
-     */
-    healthCheck(): Promise<OperationResult<{
-        status: string;
-        timestamp: string;
-    }>>;
-    /**
-     * Create memory with CLI/API routing
-     */
-    createMemory(memory: CreateMemoryRequest): Promise<OperationResult<MemoryEntry>>;
-    /**
-     * List memories with intelligent routing
-     */
-    listMemories(options?: {
-        page?: number;
-        limit?: number;
-        memory_type?: string;
-        topic_id?: string;
-        project_ref?: string;
-        status?: string;
-        tags?: string[];
-        sort?: string;
-        order?: 'asc' | 'desc';
-    }): Promise<OperationResult<PaginatedResponse<MemoryEntry>>>;
-    /**
-     * Search memories with MCP enhancement when available
-     */
-    searchMemories(request: SearchMemoryRequest): Promise<OperationResult<{
-        results: MemorySearchResult[];
-        total_results: number;
-        search_time_ms: number;
-    }>>;
-    /**
-     * Get memory by ID (API only for now)
-     */
-    getMemory(id: string): Promise<OperationResult<MemoryEntry>>;
-    /**
-     * Update memory (API only for now)
-     */
-    updateMemory(id: string, updates: UpdateMemoryRequest): Promise<OperationResult<MemoryEntry>>;
-    /**
-     * Delete memory (API only for now)
-     */
-    deleteMemory(id: string): Promise<OperationResult<void>>;
-    createTopic(topic: CreateTopicRequest): Promise<OperationResult<MemoryTopic>>;
-    getTopics(): Promise<OperationResult<MemoryTopic[]>>;
-    getTopic(id: string): Promise<OperationResult<MemoryTopic>>;
-    updateTopic(id: string, updates: Partial<CreateTopicRequest>): Promise<OperationResult<MemoryTopic>>;
-    deleteTopic(id: string): Promise<OperationResult<void>>;
-    /**
-     * Get memory statistics
-     */
-    getMemoryStats(): Promise<OperationResult<UserMemoryStats>>;
-    /**
-     * Force CLI re-detection
-     */
-    refreshCLIDetection(): Promise<void>;
-    /**
-     * Get authentication status from CLI
-     */
-    getAuthStatus(): Promise<OperationResult<CLIAuthStatus>>;
-    /**
-     * Get MCP status when available
-     */
-    getMCPStatus(): Promise<OperationResult<CLIMCPStatus>>;
-    /**
-     * Update authentication for both CLI and API client
-     */
-    setAuthToken(token: string): void;
-    setApiKey(apiKey: string): void;
-    clearAuth(): void;
-    /**
-     * Update configuration
-     */
-    updateConfig(updates: Partial<EnhancedMemoryClientConfig>): void;
-    /**
-     * Get configuration summary
-     */
-    getConfigSummary(): {
-        apiUrl: string;
-        preferCLI: boolean;
-        enableMCP: boolean;
-        capabilities?: Awaited<ReturnType<CLIIntegration['getCapabilities']>>;
-    };
-}
+type SafeJsonResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
 /**
- * Factory function to create an enhanced memory client
+ * Safely parse JSON with detailed error reporting
+ * Prevents scattered try/catch blocks throughout the codebase
  */
-declare function createEnhancedMemoryClient(config: EnhancedMemoryClientConfig): Promise<EnhancedMemoryClient>;
-
+declare function safeJsonParse<T = unknown>(input: string): SafeJsonResult<T>;
 /**
- * Configuration utilities for Memory Client SDK
- * Provides smart defaults and environment detection for CLI/MCP integration
+ * HTTP status code to error code mapping
  */
-
-interface SmartConfigOptions {
-    /** Prefer CLI integration when available (default: true in Node.js environments) */
-    preferCLI?: boolean;
-    /** Minimum CLI version required for Golden Contract compliance (default: 1.5.2) */
-    minCLIVersion?: string;
-    /** Enable MCP channel detection (default: true) */
-    enableMCP?: boolean;
-    /** API fallback configuration */
-    apiConfig?: Partial<MemoryClientConfig>;
-    /** Timeout for CLI detection in milliseconds (default: 3000) */
-    cliDetectionTimeout?: number;
-    /** Enable verbose logging for troubleshooting (default: false) */
-    verbose?: boolean;
-}
-/**
- * Environment detection utilities
- */
-declare const Environment: {
-    isNode: string | false;
-    isBrowser: boolean;
-    isVSCode: boolean;
-    isCursor: boolean;
-    isWindsurf: boolean;
-    readonly isIDE: boolean;
-    readonly supportsCLI: boolean;
-};
+declare function httpStatusToErrorCode(status: number): ErrorCode;
 /**
- * Create smart configuration with environment-aware defaults
+ * Create a standardized error response from various error sources
  */
-declare function createSmartConfig(baseConfig: Partial<MemoryClientConfig>, options?: SmartConfigOptions): EnhancedMemoryClientConfig;
+declare function createErrorResponse(message: string, code?: ErrorCode, statusCode?: number, details?: unknown): ApiErrorResponse;
 /**
- * Preset configurations for common scenarios
+ * Calculate retry delay with exponential backoff and jitter
  */
-declare const ConfigPresets: {
-    /**
-     * Development configuration with local API and CLI preference
-     */
-    development: (apiKey?: string) => EnhancedMemoryClientConfig;
-    /**
-     * Production configuration optimized for performance
-     */
-    production: (apiKey?: string) => EnhancedMemoryClientConfig;
-    /**
-     * IDE extension configuration with MCP prioritization
-     */
-    ideExtension: (apiKey?: string) => EnhancedMemoryClientConfig;
-    /**
-     * Browser-only configuration (no CLI support)
-     */
-    browserOnly: (apiKey?: string) => EnhancedMemoryClientConfig;
-    /**
-     * CLI-first configuration for server environments
-     */
-    serverCLI: (apiKey?: string) => EnhancedMemoryClientConfig;
-};
+declare function calculateRetryDelay(attempt: number, baseDelay?: number, backoff?: 'linear' | 'exponential', maxDelay?: number): number;
 /**
- * Migration helper for existing MemoryClient users
+ * Check if an error is retryable based on status code
  */
-declare function migrateToEnhanced(existingConfig: MemoryClientConfig, enhancementOptions?: SmartConfigOptions): EnhancedMemoryClientConfig;
+declare function isRetryableError(statusCode?: number): boolean;
 
 /**
  * @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';
+ * ```
  */
 
-declare const VERSION = "1.0.0";
+declare const VERSION = "2.0.0";
 declare const CLIENT_NAME = "@lanonasis/memory-client";
 declare const isBrowser: boolean;
 declare const isNode: string | false;
+declare const isEdge: boolean;
+/**
+ * Detected runtime environment
+ */
+type RuntimeEnvironment = 'browser' | 'node' | 'edge';
+/**
+ * Get the current runtime environment
+ */
+declare function getEnvironment(): RuntimeEnvironment;
+/**
+ * Configuration for the auto-detecting client factory
+ */
+interface AutoClientConfig {
+    /** API endpoint URL (required) */
+    apiUrl: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Bearer token for authentication */
+    authToken?: string;
+    /** Organization ID */
+    organizationId?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Retry configuration */
+    retry?: {
+        maxRetries?: number;
+        retryDelay?: number;
+        backoff?: 'linear' | 'exponential';
+    };
+    /** Node.js specific: prefer CLI when available */
+    preferCLI?: boolean;
+    /** Node.js specific: enable MCP channels */
+    enableMCP?: boolean;
+}
+/**
+ * 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();
+ * ```
+ */
+declare function createClient(config: AutoClientConfig): Promise<CoreMemoryClient>;
 declare const defaultConfigs: {
     readonly development: {
         readonly apiUrl: "http://localhost:3001";
         readonly timeout: 30000;
-        readonly useGateway: false;
     };
     readonly production: {
         readonly apiUrl: "https://api.lanonasis.com";
         readonly timeout: 15000;
-        readonly useGateway: true;
     };
-    readonly gateway: {
+    readonly edge: {
         readonly apiUrl: "https://api.lanonasis.com";
-        readonly timeout: 10000;
-        readonly useGateway: true;
+        readonly timeout: 5000;
     };
 };
 
-export { CLIENT_NAME, CLIIntegration, ConfigPresets, EnhancedMemoryClient, Environment, MEMORY_STATUSES, MEMORY_TYPES, MemoryClient, VERSION, createEnhancedMemoryClient, createMemoryClient, createMemorySchema, createSmartConfig, createTopicSchema, defaultConfigs, isBrowser, isNode, migrateToEnhanced, searchMemorySchema, updateMemorySchema };
-export type { ApiResponse, CLICapabilities, CLICommand, CLIInfo, CreateMemoryRequest, CreateTopicRequest, EnhancedMemoryClientConfig, MCPChannel, MemoryClientConfig, MemoryEntry, MemorySearchResult, MemoryStatus, MemoryTopic, MemoryType, OperationResult, PaginatedResponse, RoutingStrategy, SearchMemoryRequest, SmartConfigOptions, UpdateMemoryRequest, UserMemoryStats };
+export { ApiError, AuthenticationError, CHUNKING_STRATEGIES, CLIENT_NAME, CONTENT_TYPES, CoreMemoryClient, ERROR_CODES, MEMORY_STATUSES, MEMORY_TYPES, CoreMemoryClient as MemoryClient, MemoryClientError, NetworkError, NotFoundError, RateLimitError, SEARCH_MODES, ServerError, TimeoutError, VERSION, ValidationError, analyticsDateRangeSchema, calculateRetryDelay, createClient, createErrorFromStatus, createErrorResponse, createMemoryClient, createMemorySchema, createTopicSchema, defaultConfigs, enhancedSearchSchema, getEnvironment, hasData, hasError, httpStatusToErrorCode, isApiErrorResponse, isBrowser, isEdge, isNode, isRetryableError, preprocessingOptionsSchema, safeJsonParse, searchMemorySchema, updateMemorySchema };
+export type { AccessPatterns, AnalyticsDateRange, ApiErrorResponse, ApiResponse, AutoClientConfig, ChunkingStrategy, ContentChunk, ContentType, CoreMemoryClientConfig, CreateMemoryRequest, CreateMemoryWithPreprocessingRequest, CreateTopicRequest, EnhancedMemorySearchResult, EnhancedSearchRequest, EnhancedSearchResponse, ErrorCode, ExtendedMemoryStats, HourlyAccess, IntelligentMetadata, MatchingChunk, CoreMemoryClientConfig as MemoryClientConfig, MemoryEntry, MemoryIntelligence, MemorySearchResult, MemoryStatus, MemoryTopic, MemoryType, MostAccessedMemory, PaginatedResponse, PopularQuery, PreprocessingOptions, ProjectMemoryCount, RuntimeEnvironment, SafeJsonResult, SearchAnalytics, SearchAnalyticsDataPoint, SearchFilters, SearchMemoryRequest, SearchMode, TagCount, UpdateMemoryRequest, UpdateMemoryWithPreprocessingRequest, UserMemoryStats };