mindcache 1.0.1 → 2.0.0-alpha.1

package/dist/index-CFJtj3DL.d.ts

@@ -0,0 +1,279 @@
+/**
+ * Attributes that can be set on a MindCache key
+ */
+interface KeyAttributes {
+    /** If true, the key cannot be modified by AI tools */
+    readonly: boolean;
+    /** If true, the key is included in system prompts */
+    visible: boolean;
+    /** If true, the key is a system key that cannot be deleted */
+    hardcoded: boolean;
+    /** If true, the value will be processed through template injection */
+    template: boolean;
+    /** The type of value stored */
+    type: 'text' | 'image' | 'file' | 'json';
+    /** MIME type for files/images */
+    contentType?: string;
+    /** Tags for categorizing keys */
+    tags?: string[];
+}
+/**
+ * A single entry in the MindCache store
+ */
+interface STMEntry {
+    value: unknown;
+    attributes: KeyAttributes;
+}
+/**
+ * The full MindCache state (key-value pairs with attributes)
+ */
+type STM = {
+    [key: string]: STMEntry;
+};
+/**
+ * A function that is called when a key changes
+ */
+type Listener = () => void;
+/**
+ * Default attributes for new keys
+ */
+declare const DEFAULT_KEY_ATTRIBUTES: KeyAttributes;
+
+/**
+ * Cloud configuration options for MindCache constructor
+ */
+interface MindCacheCloudOptions {
+    /** Instance ID to connect to */
+    instanceId: string;
+    /** Project ID (optional, defaults to 'default') */
+    projectId?: string;
+    /** API endpoint to fetch WS token (recommended for browser) */
+    tokenEndpoint?: string;
+    /** Direct API key (server-side only, never expose in browser!) */
+    apiKey?: string;
+    /** WebSocket base URL (defaults to production) */
+    baseUrl?: string;
+}
+/**
+ * Constructor options for MindCache
+ */
+interface MindCacheOptions {
+    /** Cloud sync configuration. If omitted, runs in local-only mode. */
+    cloud?: MindCacheCloudOptions;
+}
+type ConnectionState$1 = 'disconnected' | 'connecting' | 'connected' | 'error';
+declare class MindCache {
+    private stm;
+    private listeners;
+    private globalListeners;
+    private _isRemoteUpdate;
+    private _cloudAdapter;
+    private _connectionState;
+    private _isLoaded;
+    private _cloudConfig;
+    constructor(options?: MindCacheOptions);
+    private _initCloud;
+    /**
+     * Get the current cloud connection state
+     */
+    get connectionState(): ConnectionState$1;
+    /**
+     * Check if data is loaded (true for local, true after sync for cloud)
+     */
+    get isLoaded(): boolean;
+    /**
+     * Check if this instance is connected to cloud
+     */
+    get isCloud(): boolean;
+    /**
+     * Disconnect from cloud (if connected)
+     */
+    disconnect(): void;
+    private encodeFileToBase64;
+    private createDataUrl;
+    private validateContentType;
+    /** @deprecated Use get_value instead */
+    get(key: string): any;
+    get_value(key: string, _processingStack?: Set<string>): any;
+    get_attributes(key: string): KeyAttributes | undefined;
+    set_value(key: string, value: any, attributes?: Partial<KeyAttributes>): void;
+    _setFromRemote(key: string, value: any, attributes: KeyAttributes): void;
+    isRemoteUpdate(): boolean;
+    _deleteFromRemote(key: string): void;
+    _clearFromRemote(): void;
+    set_attributes(key: string, attributes: Partial<KeyAttributes>): boolean;
+    set(key: string, value: any): void;
+    set_file(key: string, file: File, attributes?: Partial<KeyAttributes>): Promise<void>;
+    set_base64(key: string, base64Data: string, contentType: string, type?: 'image' | 'file', attributes?: Partial<KeyAttributes>): void;
+    add_image(key: string, base64Data: string, contentType?: string, attributes?: Partial<KeyAttributes>): void;
+    get_data_url(key: string): string | undefined;
+    get_base64(key: string): string | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    keys(): string[];
+    values(): any[];
+    entries(): [string, any][];
+    size(): number;
+    getAll(): Record<string, any>;
+    update(newValues: Record<string, any>): void;
+    subscribe(key: string, listener: Listener): void;
+    unsubscribe(key: string, listener: Listener): void;
+    subscribeToAll(listener: Listener): void;
+    unsubscribeFromAll(listener: Listener): void;
+    private notifyGlobalListeners;
+    injectSTM(template: string, _processingStack?: Set<string>): string;
+    getSTM(): string;
+    getSTMObject(): Record<string, any>;
+    getSTMForAPI(): Array<{
+        key: string;
+        value: any;
+        type: string;
+        contentType?: string;
+    }>;
+    getVisibleImages(): Array<{
+        type: 'file';
+        mediaType: string;
+        url: string;
+        filename?: string;
+    }>;
+    toJSON(): string;
+    fromJSON(jsonString: string): void;
+    serialize(): Record<string, STMEntry>;
+    deserialize(data: Record<string, STMEntry>): void;
+    get_system_prompt(): string;
+    private findKeyFromToolName;
+    get_aisdk_tools(): Record<string, any>;
+    executeToolCall(toolName: string, value: any): {
+        result: string;
+        key: string;
+        value: any;
+    } | null;
+    addTag(key: string, tag: string): boolean;
+    removeTag(key: string, tag: string): boolean;
+    getTags(key: string): string[];
+    getAllTags(): string[];
+    hasTag(key: string, tag: string): boolean;
+    getTagged(tag: string): string;
+    toMarkdown(): string;
+    fromMarkdown(markdown: string): void;
+}
+declare const mindcache: MindCache;
+
+/**
+ * Configuration for connecting to MindCache Cloud
+ */
+interface CloudConfig {
+    /** The project ID from mindcache.io */
+    projectId: string;
+    /** The instance ID to connect to */
+    instanceId: string;
+    /** API key for authentication (server-to-server only) */
+    apiKey?: string;
+    /** Base URL for the API (optional, defaults to production) */
+    baseUrl?: string;
+    /** Token provider function for automatic token refresh */
+    tokenProvider?: () => Promise<string>;
+}
+interface SetOperation {
+    type: 'set';
+    key: string;
+    value: unknown;
+    attributes: KeyAttributes;
+    timestamp: number;
+}
+interface DeleteOperation {
+    type: 'delete';
+    key: string;
+    timestamp: number;
+}
+interface ClearOperation {
+    type: 'clear';
+    timestamp: number;
+}
+type Operation = SetOperation | DeleteOperation | ClearOperation;
+/**
+ * Connection state
+ */
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error';
+/**
+ * Event types emitted by CloudAdapter
+ */
+interface CloudAdapterEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    synced: () => void;
+}
+
+/**
+ * CloudAdapter connects a MindCache instance to the cloud service
+ * for real-time sync and persistence.
+ *
+ * Auth modes:
+ * 1. Token (recommended): Pass a short-lived token from /api/ws-token
+ * 2. API Key (server-to-server): Pass apiKey for direct connections
+ */
+declare class CloudAdapter {
+    private config;
+    private ws;
+    private queue;
+    private mindcache;
+    private unsubscribe;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private _state;
+    private listeners;
+    private token;
+    constructor(config: CloudConfig);
+    /**
+     * Set auth token (short-lived, from /api/ws-token)
+     * Call this before connect() or use setTokenProvider for auto-refresh
+     */
+    setToken(token: string): void;
+    /**
+     * Set a function that returns a fresh token
+     * Used for automatic token refresh on reconnect
+     */
+    setTokenProvider(provider: () => Promise<string>): void;
+    /**
+     * Get current connection state
+     */
+    get state(): ConnectionState;
+    /**
+     * Attach to a MindCache instance and start syncing
+     */
+    attach(mc: MindCache): void;
+    /**
+     * Detach from the MindCache instance
+     */
+    detach(): void;
+    /**
+     * Connect to the cloud service
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the cloud service
+     */
+    disconnect(): void;
+    /**
+     * Push an operation to the cloud
+     */
+    push(op: Operation): void;
+    /**
+     * Add event listener
+     */
+    on<K extends keyof CloudAdapterEvents>(event: K, listener: CloudAdapterEvents[K]): void;
+    /**
+     * Remove event listener
+     */
+    off<K extends keyof CloudAdapterEvents>(event: K, listener: CloudAdapterEvents[K]): void;
+    private emit;
+    private setupWebSocket;
+    private handleMessage;
+    private flushQueue;
+    private scheduleReconnect;
+    private syncLocalChanges;
+}
+
+export { type CloudConfig as C, type DeleteOperation as D, type KeyAttributes as K, type Listener as L, MindCache as M, type Operation as O, type SetOperation as S, CloudAdapter as a, type ConnectionState as b, type CloudAdapterEvents as c, type ClearOperation as d, type STM as e, type STMEntry as f, type MindCacheOptions as g, type MindCacheCloudOptions as h, DEFAULT_KEY_ATTRIBUTES as i, mindcache as m };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { a as CloudAdapter, c as CloudAdapterEvents, C as CloudConfig, b as ConnectionState, i as DEFAULT_KEY_ATTRIBUTES, K as KeyAttributes, L as Listener, M as MindCache, h as MindCacheCloudOptions, g as MindCacheOptions, e as STM, f as STMEntry, m as mindcache } from './index-CFJtj3DL.mjs';

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { a as CloudAdapter, c as CloudAdapterEvents, C as CloudConfig, b as ConnectionState, i as DEFAULT_KEY_ATTRIBUTES, K as KeyAttributes, L as Listener, M as MindCache, h as MindCacheCloudOptions, g as MindCacheOptions, e as STM, f as STMEntry, m as mindcache } from './index-CFJtj3DL.js';