@cmdoss/memwal-sdk 0.6.1 → 0.7.0

package/src/index.ts

@@ -33,7 +33,12 @@ import type { PipelineConfig, PipelineManagerConfig } from './pipeline';
 // ==================== SERVICES ====================
 // Business logic services
 export { StorageService } from './services/StorageService';
-export { EmbeddingService } from './services/EmbeddingService';
+export {
+  EmbeddingService,
+  getSharedEmbeddingService,
+  clearSharedEmbeddingServices,
+  getSharedEmbeddingStats,
+} from './services/EmbeddingService';
 export { GeminiAIService } from './services/GeminiAIService';
 export { QueryService } from './services/QueryService';
 export { ClassifierService } from './services/ClassifierService';
@@ -454,6 +459,25 @@ export type { RebuildIndexOptions, RebuildIndexResult } from './utils/rebuildInd
 export { rebuildIndexNode, hasExistingIndexNode, clearIndexNode } from './utils/rebuildIndexNode';
 export type { RebuildIndexNodeOptions, RebuildIndexNodeResult } from './utils/rebuildIndexNode';
 
+// MemoryIndex on-chain utilities
+export {
+  getMemoryIndex,
+  updateMemoryIndexOnChain,
+  createMemoryIndexOnChain,
+  syncIndexAndUpdateOnChain,
+  uploadPlaceholderToWalrus
+} from './utils/memoryIndexOnChain';
+export type {
+  OnChainMemoryIndex,
+  GetMemoryIndexOptions,
+  UpdateMemoryIndexOnChainOptions,
+  CreateMemoryIndexOnChainOptions,
+  UpdateMemoryIndexResult,
+  CreateMemoryIndexResult,
+  SyncAndUpdateOptions,
+  SyncAndUpdateResult
+} from './utils/memoryIndexOnChain';
+
 // ==================== AI SDK INTEGRATION ====================
 // AI SDK tools and vector store for Vercel AI SDK integration
 export { pdwTools } from './ai-sdk/tools';

package/src/permissions/ConsentRepository.browser.ts

@@ -0,0 +1,249 @@
+/**
+ * Browser-safe Consent Repository implementations
+ *
+ * This file contains only browser-compatible implementations.
+ * FileSystemConsentRepository is excluded as it requires Node.js fs/promises.
+ */
+
+import {
+  ConsentRequestRecord,
+  ConsentStatus,
+} from '../core/types/wallet.js';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+
+export interface ConsentRepository {
+  save(request: ConsentRequestRecord): Promise<void>;
+  updateStatus(requestId: string, status: ConsentStatus, updatedAt: number): Promise<void>;
+  getById(requestId: string): Promise<ConsentRequestRecord | null>;
+  listByTarget(targetWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]>;
+  listByRequester(requesterWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]>;
+  delete(requestId: string): Promise<void>;
+}
+
+interface StoredConsentRecord extends ConsentRequestRecord {}
+
+function normalizeRecord(record: ConsentRequestRecord): StoredConsentRecord {
+  return {
+    ...record,
+    requesterWallet: normalizeSuiAddress(record.requesterWallet),
+    targetWallet: normalizeSuiAddress(record.targetWallet),
+  };
+}
+
+export class InMemoryConsentRepository implements ConsentRepository {
+  private store = new Map<string, StoredConsentRecord>();
+
+  async save(request: ConsentRequestRecord): Promise<void> {
+    const normalized = normalizeRecord(request);
+    this.store.set(normalized.requestId, normalized);
+  }
+
+  async updateStatus(requestId: string, status: ConsentStatus, updatedAt: number): Promise<void> {
+    const record = this.store.get(requestId);
+    if (!record) {
+      return;
+    }
+    this.store.set(requestId, {
+      ...record,
+      status,
+      updatedAt,
+    });
+  }
+
+  async getById(requestId: string): Promise<ConsentRequestRecord | null> {
+    const record = this.store.get(requestId);
+    return record ? { ...record } : null;
+  }
+
+  async listByTarget(targetWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]> {
+    const normalizedTarget = normalizeSuiAddress(targetWallet);
+    return Array.from(this.store.values())
+      .filter((record) => record.targetWallet === normalizedTarget)
+      .filter((record) => (status ? record.status === status : true))
+      .map((record) => ({ ...record }));
+  }
+
+  async listByRequester(requesterWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]> {
+    const normalizedRequester = normalizeSuiAddress(requesterWallet);
+    return Array.from(this.store.values())
+      .filter((record) => record.requesterWallet === normalizedRequester)
+      .filter((record) => (status ? record.status === status : true))
+      .map((record) => ({ ...record }));
+  }
+
+  async delete(requestId: string): Promise<void> {
+    this.store.delete(requestId);
+  }
+}
+
+/**
+ * IndexedDBConsentRepository - Browser-compatible implementation
+ * Uses IndexedDB for persistent storage in browser environments.
+ */
+export class IndexedDBConsentRepository implements ConsentRepository {
+  private dbName = 'pdw-consent-store';
+  private storeName = 'consent-requests';
+  private dbVersion = 1;
+  private db: IDBDatabase | null = null;
+
+  constructor(options?: { dbName?: string }) {
+    if (options?.dbName) {
+      this.dbName = options.dbName;
+    }
+  }
+
+  private async getDB(): Promise<IDBDatabase> {
+    if (this.db) {
+      return this.db;
+    }
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.dbVersion);
+
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(request.result);
+      };
+
+      request.onupgradeneeded = (event) => {
+        const db = (event.target as IDBOpenDBRequest).result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          const store = db.createObjectStore(this.storeName, { keyPath: 'requestId' });
+          store.createIndex('targetWallet', 'targetWallet', { unique: false });
+          store.createIndex('requesterWallet', 'requesterWallet', { unique: false });
+          store.createIndex('status', 'status', { unique: false });
+        }
+      };
+    });
+  }
+
+  async save(request: ConsentRequestRecord): Promise<void> {
+    const db = await this.getDB();
+    const normalized = normalizeRecord(request);
+
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readwrite');
+      const store = tx.objectStore(this.storeName);
+      const req = store.put(normalized);
+
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => resolve();
+    });
+  }
+
+  async updateStatus(requestId: string, status: ConsentStatus, updatedAt: number): Promise<void> {
+    const record = await this.getById(requestId);
+    if (!record) {
+      return;
+    }
+
+    await this.save({
+      ...record,
+      status,
+      updatedAt,
+    });
+  }
+
+  async getById(requestId: string): Promise<ConsentRequestRecord | null> {
+    const db = await this.getDB();
+
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readonly');
+      const store = tx.objectStore(this.storeName);
+      const req = store.get(requestId);
+
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => {
+        const record = req.result as StoredConsentRecord | undefined;
+        resolve(record ? { ...record } : null);
+      };
+    });
+  }
+
+  async listByTarget(targetWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]> {
+    const normalizedTarget = normalizeSuiAddress(targetWallet);
+    const db = await this.getDB();
+
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readonly');
+      const store = tx.objectStore(this.storeName);
+      const index = store.index('targetWallet');
+      const req = index.getAll(normalizedTarget);
+
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => {
+        let records = req.result as StoredConsentRecord[];
+        if (status) {
+          records = records.filter((r) => r.status === status);
+        }
+        resolve(records.map((r) => ({ ...r })));
+      };
+    });
+  }
+
+  async listByRequester(requesterWallet: string, status?: ConsentStatus): Promise<ConsentRequestRecord[]> {
+    const normalizedRequester = normalizeSuiAddress(requesterWallet);
+    const db = await this.getDB();
+
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readonly');
+      const store = tx.objectStore(this.storeName);
+      const index = store.index('requesterWallet');
+      const req = index.getAll(normalizedRequester);
+
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => {
+        let records = req.result as StoredConsentRecord[];
+        if (status) {
+          records = records.filter((r) => r.status === status);
+        }
+        resolve(records.map((r) => ({ ...r })));
+      };
+    });
+  }
+
+  async delete(requestId: string): Promise<void> {
+    const db = await this.getDB();
+
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, 'readwrite');
+      const store = tx.objectStore(this.storeName);
+      const req = store.delete(requestId);
+
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => resolve();
+    });
+  }
+
+  /**
+   * Close the database connection
+   */
+  close(): void {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+
+/**
+ * Factory function to create the appropriate ConsentRepository for browser
+ */
+export function createBrowserConsentRepository(options?: {
+  dbName?: string;
+  forceInMemory?: boolean;
+}): ConsentRepository {
+  // Force in-memory for testing
+  if (options?.forceInMemory) {
+    return new InMemoryConsentRepository();
+  }
+
+  // Browser environment - use IndexedDB
+  if (typeof window !== 'undefined' && typeof indexedDB !== 'undefined') {
+    return new IndexedDBConsentRepository({ dbName: options?.dbName });
+  }
+
+  // Fallback to in-memory
+  return new InMemoryConsentRepository();
+}

package/src/retrieval/MemoryRetrievalService.ts

@@ -182,10 +182,15 @@ export class MemoryRetrievalService {
   private contentCache = new Map<string, { content: string; metadata: any; timestamp: number }>();
   private analyticsCache = new Map<string, { analytics: any; timestamp: number }>();
   
-  // Cache TTL settings
-  private readonly QUERY_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-  private readonly CONTENT_CACHE_TTL = 30 * 60 * 1000; // 30 minutes
-  private readonly ANALYTICS_CACHE_TTL = 60 * 60 * 1000; // 1 hour
+  // Cache TTL settings (configurable)
+  private readonly QUERY_CACHE_TTL: number;
+  private readonly CONTENT_CACHE_TTL: number;
+  private readonly ANALYTICS_CACHE_TTL: number;
+
+  // Cache size limits to prevent memory leaks (configurable)
+  private readonly MAX_QUERY_CACHE_SIZE: number;
+  private readonly MAX_CONTENT_CACHE_SIZE: number;
+  private readonly MAX_ANALYTICS_CACHE_SIZE: number;
 
   constructor(config?: {
     embeddingService?: EmbeddingService;
@@ -196,7 +201,29 @@ export class MemoryRetrievalService {
     encryptionService?: EncryptionService;
     batchManager?: BatchManager;
     decryptionConfig?: DecryptionConfig;
+    /** Cache configuration for memory management */
+    cacheConfig?: {
+      /** Query cache TTL in ms (default: 5 minutes) */
+      queryCacheTtlMs?: number;
+      /** Content cache TTL in ms (default: 30 minutes) */
+      contentCacheTtlMs?: number;
+      /** Analytics cache TTL in ms (default: 1 hour) */
+      analyticsCacheTtlMs?: number;
+      /** Max query cache entries (default: 100) */
+      maxQueryCacheSize?: number;
+      /** Max content cache entries (default: 50) */
+      maxContentCacheSize?: number;
+      /** Max analytics cache entries (default: 100) */
+      maxAnalyticsCacheSize?: number;
+    };
   }) {
+    // Initialize cache settings with configurable defaults
+    this.QUERY_CACHE_TTL = config?.cacheConfig?.queryCacheTtlMs ?? 5 * 60 * 1000; // 5 minutes
+    this.CONTENT_CACHE_TTL = config?.cacheConfig?.contentCacheTtlMs ?? 30 * 60 * 1000; // 30 minutes
+    this.ANALYTICS_CACHE_TTL = config?.cacheConfig?.analyticsCacheTtlMs ?? 60 * 60 * 1000; // 1 hour
+    this.MAX_QUERY_CACHE_SIZE = config?.cacheConfig?.maxQueryCacheSize ?? 100;
+    this.MAX_CONTENT_CACHE_SIZE = config?.cacheConfig?.maxContentCacheSize ?? 50; // Content can be large
+    this.MAX_ANALYTICS_CACHE_SIZE = config?.cacheConfig?.maxAnalyticsCacheSize ?? 100;
     // Initialize services (can be injected or created with default configs)
     this.embeddingService = config?.embeddingService ?? new EmbeddingService();
     this.storageManager = config?.storageManager ?? new StorageManager();
@@ -684,9 +711,56 @@ export class MemoryRetrievalService {
   }
 
   private cacheQuery(key: string, result: RetrievalContext): void {
+    this.enforceCacheLimit(this.queryCache, this.MAX_QUERY_CACHE_SIZE, this.QUERY_CACHE_TTL);
     this.queryCache.set(key, { result, timestamp: Date.now() });
   }
 
+  /**
+   * Cache content with size limit enforcement
+   */
+  private cacheContent(key: string, content: string, metadata: any): void {
+    this.enforceCacheLimit(this.contentCache, this.MAX_CONTENT_CACHE_SIZE, this.CONTENT_CACHE_TTL);
+    this.contentCache.set(key, { content, metadata, timestamp: Date.now() });
+  }
+
+  /**
+   * Cache analytics with size limit enforcement
+   */
+  private cacheAnalytics(key: string, analytics: any): void {
+    this.enforceCacheLimit(this.analyticsCache, this.MAX_ANALYTICS_CACHE_SIZE, this.ANALYTICS_CACHE_TTL);
+    this.analyticsCache.set(key, { analytics, timestamp: Date.now() });
+  }
+
+  /**
+   * Enforce cache size limit using LRU eviction (oldest entries first)
+   * Also removes expired entries based on TTL
+   */
+  private enforceCacheLimit<T extends { timestamp: number }>(
+    cache: Map<string, T>,
+    maxSize: number,
+    ttl: number
+  ): void {
+    // First, clean up expired entries
+    const now = Date.now();
+
+    for (const [key, value] of cache.entries()) {
+      if (now - value.timestamp > ttl) {
+        cache.delete(key);
+      }
+    }
+
+    // If still over limit, remove oldest entries (LRU)
+    if (cache.size >= maxSize) {
+      const entries = Array.from(cache.entries())
+        .sort((a, b) => a[1].timestamp - b[1].timestamp);
+
+      const toRemove = cache.size - maxSize + 1; // +1 to make room for new entry
+      for (let i = 0; i < toRemove && i < entries.length; i++) {
+        cache.delete(entries[i][0]);
+      }
+    }
+  }
+
   // ==================== UTILITY METHODS ====================
 
   private calculateCacheHitRate(): number {

package/src/services/EmbeddingService.ts

@@ -83,7 +83,7 @@ export interface EmbeddingConfig {
 
   /**
    * Embedding dimensions (optional, provider-dependent)
-   * - Google: Up to 768
+   * - Google: Up to 3072
    * - OpenAI: 256, 512, 1024, 1536, 3072 (depending on model)
    * - OpenRouter: Depends on the underlying model
    * - Cohere: Model-specific
@@ -704,3 +704,68 @@ export class EmbeddingService {
 }
 
 export default EmbeddingService;
+
+// ==================== Singleton Pattern ====================
+
+/**
+ * Generate config key for singleton cache
+ */
+function getConfigKey(config: EmbeddingConfig): string {
+  const provider = config.provider || 'google';
+  const modelName = typeof config.model === 'string'
+    ? config.model
+    : (config.modelName || 'default');
+  const dimensions = config.dimensions || 'default';
+  return `${provider}:${modelName}:${dimensions}`;
+}
+
+/** Singleton cache */
+const sharedInstances = new Map<string, EmbeddingService>();
+
+/**
+ * Get or create a shared EmbeddingService instance (Singleton)
+ *
+ * All clients with same provider/model/dimensions share one instance.
+ * Reduces memory usage and connection overhead.
+ *
+ * @example
+ * ```typescript
+ * // Instead of: new EmbeddingService({ apiKey, modelName })
+ * const embedding = getSharedEmbeddingService({ apiKey, modelName });
+ * ```
+ */
+export function getSharedEmbeddingService(config: EmbeddingConfig): EmbeddingService {
+  const key = getConfigKey(config);
+
+  let instance = sharedInstances.get(key);
+  if (!instance) {
+    console.log(`🔧 [Singleton] Creating shared EmbeddingService: ${key}`);
+    instance = new EmbeddingService(config);
+    sharedInstances.set(key, instance);
+  }
+
+  return instance;
+}
+
+/**
+ * Clear all shared instances (for testing)
+ */
+export function clearSharedEmbeddingServices(): void {
+  sharedInstances.clear();
+}
+
+/**
+ * Get singleton stats
+ */
+export function getSharedEmbeddingStats(): {
+  instanceCount: number;
+  instances: Array<{ key: string; stats: ReturnType<EmbeddingService['getStats']> }>;
+} {
+  return {
+    instanceCount: sharedInstances.size,
+    instances: Array.from(sharedInstances.entries()).map(([key, svc]) => ({
+      key,
+      stats: svc.getStats(),
+    })),
+  };
+}