@lanonasis/memory-client 1.0.1 → 2.0.0

package/dist/core/index.d.ts

@@ -0,0 +1,421 @@
+import { z } from 'zod';
+
+/**
+ * Memory types supported by the service
+ */
+declare const MEMORY_TYPES: readonly ["context", "project", "knowledge", "reference", "personal", "workflow"];
+type MemoryType = typeof MEMORY_TYPES[number];
+/**
+ * Memory status values
+ */
+declare const MEMORY_STATUSES: readonly ["active", "archived", "draft", "deleted"];
+type MemoryStatus = typeof MEMORY_STATUSES[number];
+/**
+ * Core memory entry interface
+ */
+interface MemoryEntry {
+    id: string;
+    title: string;
+    content: string;
+    summary?: string;
+    memory_type: MemoryType;
+    status: MemoryStatus;
+    relevance_score?: number;
+    access_count: number;
+    last_accessed?: string;
+    user_id: string;
+    topic_id?: string;
+    project_ref?: string;
+    tags: string[];
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Memory topic for organization
+ */
+interface MemoryTopic {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    icon?: string;
+    user_id: string;
+    parent_topic_id?: string;
+    is_system: boolean;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Memory search result with similarity score
+ */
+interface MemorySearchResult extends MemoryEntry {
+    similarity_score: number;
+}
+/**
+ * User memory statistics
+ */
+interface UserMemoryStats {
+    total_memories: number;
+    memories_by_type: Record<MemoryType, number>;
+    total_topics: number;
+    most_accessed_memory?: string;
+    recent_memories: string[];
+}
+/**
+ * Validation schemas using Zod
+ */
+declare const createMemorySchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    memory_type: z.ZodDefault<z.ZodEnum<{
+        context: "context";
+        project: "project";
+        knowledge: "knowledge";
+        reference: "reference";
+        personal: "personal";
+        workflow: "workflow";
+    }>>;
+    topic_id: z.ZodOptional<z.ZodString>;
+    project_ref: z.ZodOptional<z.ZodString>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const updateMemorySchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    memory_type: z.ZodOptional<z.ZodEnum<{
+        context: "context";
+        project: "project";
+        knowledge: "knowledge";
+        reference: "reference";
+        personal: "personal";
+        workflow: "workflow";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        draft: "draft";
+        deleted: "deleted";
+    }>>;
+    topic_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    project_ref: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const searchMemorySchema: z.ZodObject<{
+    query: z.ZodString;
+    memory_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        context: "context";
+        project: "project";
+        knowledge: "knowledge";
+        reference: "reference";
+        personal: "personal";
+        workflow: "workflow";
+    }>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    topic_id: z.ZodOptional<z.ZodString>;
+    project_ref: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        draft: "draft";
+        deleted: "deleted";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    threshold: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const createTopicSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    parent_topic_id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Inferred types from schemas
+ */
+type CreateMemoryRequest = z.infer<typeof createMemorySchema>;
+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 CoreMemoryClientConfig {
+    /** API endpoint URL */
+    apiUrl: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Bearer token for authentication (alternative to API key) */
+    authToken?: string;
+    /** 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;
+    /** 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
+ */
+interface ApiResponse<T> {
+    data?: 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
+ */
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        pages: number;
+    };
+}
+/**
+ * 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 CoreMemoryClient {
+    private config;
+    private baseHeaders;
+    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
+     */
+    private request;
+    /**
+     * Test the API connection and authentication
+     */
+    healthCheck(): Promise<ApiResponse<{
+        status: string;
+        timestamp: string;
+    }>>;
+    /**
+     * Create a new memory
+     */
+    createMemory(memory: CreateMemoryRequest): Promise<ApiResponse<MemoryEntry>>;
+    /**
+     * Get a memory by ID
+     */
+    getMemory(id: string): Promise<ApiResponse<MemoryEntry>>;
+    /**
+     * Update an existing memory
+     */
+    updateMemory(id: string, updates: UpdateMemoryRequest): Promise<ApiResponse<MemoryEntry>>;
+    /**
+     * Delete a memory
+     */
+    deleteMemory(id: string): Promise<ApiResponse<void>>;
+    /**
+     * List memories with optional filtering and pagination
+     */
+    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<ApiResponse<PaginatedResponse<MemoryEntry>>>;
+    /**
+     * Search memories using semantic search
+     */
+    searchMemories(request: SearchMemoryRequest): Promise<ApiResponse<{
+        results: MemorySearchResult[];
+        total_results: number;
+        search_time_ms: number;
+    }>>;
+    /**
+     * Bulk delete multiple memories
+     */
+    bulkDeleteMemories(memoryIds: string[]): Promise<ApiResponse<{
+        deleted_count: number;
+        failed_ids: string[];
+    }>>;
+    /**
+     * Create a new topic
+     */
+    createTopic(topic: CreateTopicRequest): Promise<ApiResponse<MemoryTopic>>;
+    /**
+     * Get all topics
+     */
+    getTopics(): Promise<ApiResponse<MemoryTopic[]>>;
+    /**
+     * Get a topic by ID
+     */
+    getTopic(id: string): Promise<ApiResponse<MemoryTopic>>;
+    /**
+     * Update a topic
+     */
+    updateTopic(id: string, updates: Partial<CreateTopicRequest>): Promise<ApiResponse<MemoryTopic>>;
+    /**
+     * Delete a topic
+     */
+    deleteTopic(id: string): Promise<ApiResponse<void>>;
+    /**
+     * Get user memory statistics
+     */
+    getMemoryStats(): Promise<ApiResponse<UserMemoryStats>>;
+    /**
+     * Update authentication token
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey: string): void;
+    /**
+     * Clear authentication
+     */
+    clearAuth(): void;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<CoreMemoryClientConfig>): void;
+    /**
+     * Get current configuration (excluding sensitive data)
+     */
+    getConfig(): Omit<CoreMemoryClientConfig, 'apiKey' | 'authToken'>;
+}
+/**
+ * Factory function to create a new Core Memory Client instance
+ */
+declare function createMemoryClient(config: CoreMemoryClientConfig): CoreMemoryClient;
+
+/**
+ * Error handling for Memory Client
+ * Browser-safe, no Node.js dependencies
+ */
+/**
+ * Base error class for Memory Client errors
+ */
+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);
+}
+/**
+ * Network/API error
+ */
+declare class ApiError extends MemoryClientError {
+    constructor(message: string, statusCode?: number, details?: unknown);
+}
+/**
+ * Authentication error
+ */
+declare class AuthenticationError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Validation error
+ */
+declare class ValidationError extends MemoryClientError {
+    constructor(message: string, details?: unknown);
+}
+/**
+ * Timeout error
+ */
+declare class TimeoutError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Rate limit error
+ */
+declare class RateLimitError extends MemoryClientError {
+    constructor(message?: string);
+}
+/**
+ * Not found error
+ */
+declare class NotFoundError extends MemoryClientError {
+    constructor(resource: string);
+}
+
+/**
+ * @lanonasis/memory-client/core
+ *
+ * Pure browser-safe Memory Client
+ * 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
+ */
+
+declare const VERSION = "2.0.0";
+declare const CLIENT_NAME = "@lanonasis/memory-client";
+declare const isBrowser: boolean;
+declare const isNode: string | false;
+declare const defaultConfigs: {
+    readonly development: {
+        readonly apiUrl: "http://localhost:3001";
+        readonly timeout: 30000;
+    };
+    readonly production: {
+        readonly apiUrl: "https://api.lanonasis.com";
+        readonly timeout: 15000;
+    };
+    readonly edge: {
+        readonly apiUrl: "https://api.lanonasis.com";
+        readonly timeout: 5000;
+    };
+};
+
+export { ApiError as ApiErrorClass, AuthenticationError, CLIENT_NAME, CoreMemoryClient, MEMORY_STATUSES, MEMORY_TYPES, MemoryClientError, NotFoundError, RateLimitError, TimeoutError, VERSION, ValidationError, createMemoryClient, createMemorySchema, createTopicSchema, defaultConfigs, isBrowser, isNode, searchMemorySchema, updateMemorySchema };
+export type { ApiError$1 as ApiError, ApiResponse, CoreMemoryClientConfig, CreateMemoryRequest, CreateTopicRequest, MemoryEntry, MemorySearchResult, MemoryStatus, MemoryTopic, MemoryType, PaginatedResponse, SearchMemoryRequest, UpdateMemoryRequest, UserMemoryStats };