@lanonasis/memory-client 1.0.1 → 2.0.0

package/dist/index.d.ts

@@ -143,22 +143,50 @@ type UpdateMemoryRequest = z.infer<typeof updateMemorySchema>;
 type SearchMemoryRequest = z.infer<typeof searchMemorySchema>;
 type CreateTopicRequest = z.infer<typeof createTopicSchema>;
 
+/**
+ * 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: ApiError$1) => void;
+    /** Called before each request */
+    onRequest?: (endpoint: string) => void;
+    /** Called after each response */
+    onResponse?: (endpoint: string, duration: number) => void;
 }
 /**
  * Standard API response wrapper
@@ -168,6 +196,15 @@ interface ApiResponse<T> {
     error?: string;
     message?: string;
 }
+/**
+ * API error with details
+ */
+interface ApiError$1 {
+    message: string;
+    code?: string;
+    statusCode?: number;
+    details?: unknown;
+}
 /**
  * Paginated response for list operations
  */
@@ -181,12 +218,20 @@ 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);
+    /**
+     * 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
      */
@@ -282,375 +327,100 @@ declare class MemoryClient {
     /**
      * Update configuration
      */
-    updateConfig(updates: Partial<MemoryClientConfig>): void;
+    updateConfig(updates: Partial<CoreMemoryClientConfig>): void;
     /**
      * Get current configuration (excluding sensitive data)
      */
-    getConfig(): Omit<MemoryClientConfig, 'apiKey' | 'authToken'>;
+    getConfig(): Omit<CoreMemoryClientConfig, 'apiKey' | 'authToken'>;
 }
 /**
- * Factory function to create a new Memory Client instance
+ * Factory function to create a new Core Memory Client instance
  */
-declare function createMemoryClient(config: MemoryClientConfig): MemoryClient;
+declare function createMemoryClient(config: CoreMemoryClientConfig): CoreMemoryClient;
 
 /**
- * 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
+ * Error handling for Memory Client
+ * Browser-safe, no Node.js dependencies
  */
-
-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
+ * Base error class for Memory Client errors
  */
-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>>;
-    /**
-     * Get preferred CLI command (onasis for Golden Contract, fallback to lanonasis)
-     */
-    private getPreferredCLICommand;
-    /**
-     * Memory operations via CLI
-     */
-    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?: {
-        limit?: number;
-        memoryTypes?: string[];
-    }): Promise<ApiResponse<{
-        results: MemorySearchResult[];
-        total_results: number;
-        search_time_ms: number;
-    }>>;
-    /**
-     * Health check via CLI
-     */
-    healthCheckViaCLI(): Promise<ApiResponse<{
-        status: string;
-        timestamp: string;
-    }>>;
-    /**
-     * MCP-specific operations
-     */
-    getMCPStatus(): Promise<ApiResponse<CLIMCPStatus>>;
-    listMCPTools(): Promise<ApiResponse<{
-        tools: CLIMCPTool[];
-    }>>;
-    /**
-     * Authentication operations
-     */
-    getAuthStatus(): Promise<ApiResponse<CLIAuthStatus>>;
-    /**
-     * Check if specific CLI features are available
-     */
-    getCapabilities(): Promise<{
-        cliAvailable: boolean;
-        version?: string;
-        mcpSupport: boolean;
-        authenticated: boolean;
-        goldenContract: boolean;
-    }>;
-    private isGoldenContractCompliant;
-    /**
-     * Force refresh CLI detection
-     */
-    refresh(): Promise<CLIInfo>;
-    /**
-     * Get cached CLI info without re-detection
-     */
-    getCachedInfo(): CLIInfo | null;
+declare class MemoryClientError extends Error {
+    code?: string | undefined;
+    statusCode?: number | undefined;
+    details?: unknown | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined, details?: unknown | undefined);
 }
-
 /**
- * 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
+ * Network/API error
  */
-
-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;
+declare class ApiError extends MemoryClientError {
+    constructor(message: string, statusCode?: number, details?: unknown);
 }
 /**
- * Enhanced Memory Client with intelligent CLI/API routing
+ * Authentication error
  */
-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']>>;
-    };
+declare class AuthenticationError extends MemoryClientError {
+    constructor(message?: string);
 }
 /**
- * Factory function to create an enhanced memory client
+ * Validation error
  */
-declare function createEnhancedMemoryClient(config: EnhancedMemoryClientConfig): Promise<EnhancedMemoryClient>;
-
-/**
- * Configuration utilities for Memory Client SDK
- * Provides smart defaults and environment detection for CLI/MCP integration
- */
-
-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;
+declare class ValidationError extends MemoryClientError {
+    constructor(message: string, details?: unknown);
 }
 /**
- * Environment detection utilities
+ * Timeout error
  */
-declare const Environment: {
-    isNode: string | false;
-    isBrowser: boolean;
-    isVSCode: boolean;
-    isCursor: boolean;
-    isWindsurf: boolean;
-    readonly isIDE: boolean;
-    readonly supportsCLI: boolean;
-};
-/**
- * Create smart configuration with environment-aware defaults
- */
-declare function createSmartConfig(baseConfig: Partial<MemoryClientConfig>, options?: SmartConfigOptions): EnhancedMemoryClientConfig;
+declare class TimeoutError extends MemoryClientError {
+    constructor(message?: string);
+}
 /**
- * Preset configurations for common scenarios
+ * Rate limit error
  */
-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 class RateLimitError extends MemoryClientError {
+    constructor(message?: string);
+}
 /**
- * Migration helper for existing MemoryClient users
+ * Not found error
  */
-declare function migrateToEnhanced(existingConfig: MemoryClientConfig, enhancementOptions?: SmartConfigOptions): EnhancedMemoryClientConfig;
+declare class NotFoundError extends MemoryClientError {
+    constructor(resource: string);
+}
 
 /**
  * @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;
@@ -658,19 +428,16 @@ 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 as ApiErrorClass, AuthenticationError, CLIENT_NAME, CoreMemoryClient, MEMORY_STATUSES, MEMORY_TYPES, CoreMemoryClient as MemoryClient, MemoryClientError, NotFoundError, RateLimitError, TimeoutError, VERSION, ValidationError, createMemoryClient, createMemorySchema, createTopicSchema, defaultConfigs, isBrowser, isNode, searchMemorySchema, updateMemorySchema };
+export type { ApiError$1 as ApiError, ApiResponse, CoreMemoryClientConfig, CreateMemoryRequest, CreateTopicRequest, CoreMemoryClientConfig as MemoryClientConfig, MemoryEntry, MemorySearchResult, MemoryStatus, MemoryTopic, MemoryType, PaginatedResponse, SearchMemoryRequest, UpdateMemoryRequest, UserMemoryStats };