@yamo/memory-mesh 3.0.0 → 3.0.2

package/lib/memory/embeddings/factory.d.ts

@@ -2,55 +2,53 @@
  * EmbeddingFactory - Multi-provider embedding with automatic fallback
  * Manages primary and fallback embedding services
  */
-import EmbeddingService, { ServiceConfig, ServiceStats } from "./service.js";
-export interface FactoryStats {
-    configured: boolean;
-    primary: ServiceStats | null;
-    fallbacks: ServiceStats[];
-}
-export interface InitResult {
-    success: boolean;
-    primary: string | null;
-    fallbacks: string[];
-}
+import EmbeddingService from "./service.js";
 declare class EmbeddingFactory {
-    primaryService: EmbeddingService | null;
-    fallbackServices: EmbeddingService[];
-    configured: boolean;
-    ServiceClass: typeof EmbeddingService;
+    primaryService: any;
+    fallbackServices: any;
+    configured: any;
+    ServiceClass: any;
     constructor(ServiceClass?: typeof EmbeddingService);
     /**
      * Configure embedding services with fallback chain
      * @param {Array} configs - Array of { modelType, modelName, priority, apiKey }
      * @returns {Object} Success status
      */
-    configure(configs: ServiceConfig[]): {
+    configure(configs: any): {
         success: boolean;
     };
     /**
      * Initialize all configured services
      * @returns {Promise<Object>} Initialization status
      */
-    init(): Promise<InitResult>;
+    init(): Promise<{
+        success: boolean;
+        primary: any;
+        fallbacks: any;
+    }>;
     /**
      * Generate embedding with automatic fallback
      * @param {string} text - Text to embed
      * @param {Object} options - Options
      * @returns {Promise<number[]>} Embedding vector
      */
-    embed(text: string, options?: any): Promise<number[]>;
+    embed(text: any, options?: {}): Promise<any>;
     /**
      * Generate embeddings for batch of texts
      * @param {string[]} texts - Texts to embed
      * @param {Object} options - Options
      * @returns {Promise<number[][]>} Array of embedding vectors
      */
-    embedBatch(texts: string[], options?: any): Promise<number[][]>;
+    embedBatch(texts: any, options?: {}): Promise<any>;
     /**
      * Get factory statistics
      * @returns {Object} Statistics
      */
-    getStats(): FactoryStats;
+    getStats(): {
+        configured: any;
+        primary: any;
+        fallbacks: any;
+    };
     /**
      * Clear all caches
      */

package/lib/memory/embeddings/factory.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * EmbeddingFactory - Multi-provider embedding with automatic fallback
  * Manages primary and fallback embedding services

package/lib/memory/embeddings/factory.ts

@@ -1,192 +1,149 @@
+// @ts-nocheck
 /**
  * EmbeddingFactory - Multi-provider embedding with automatic fallback
  * Manages primary and fallback embedding services
  */
-
-import EmbeddingService, { ServiceConfig, ServiceStats } from "./service.js";
+import EmbeddingService from "./service.js";
 import { ConfigurationError, EmbeddingError } from "../adapters/errors.js";
 import { createLogger } from "../../utils/logger.js";
-
 const logger = createLogger("embedding-factory");
-
-export interface FactoryStats {
-  configured: boolean;
-  primary: ServiceStats | null;
-  fallbacks: ServiceStats[];
-}
-
-export interface InitResult {
-  success: boolean;
-  primary: string | null;
-  fallbacks: string[];
-}
-
 class EmbeddingFactory {
-  primaryService: EmbeddingService | null;
-  fallbackServices: EmbeddingService[];
-  configured: boolean;
-  ServiceClass: typeof EmbeddingService;
-
-  constructor(ServiceClass: typeof EmbeddingService = EmbeddingService) {
-    this.primaryService = null;
-    this.fallbackServices = [];
-    this.configured = false;
-    this.ServiceClass = ServiceClass;
-  }
-
-  /**
-   * Configure embedding services with fallback chain
-   * @param {Array} configs - Array of { modelType, modelName, priority, apiKey }
-   * @returns {Object} Success status
-   */
-  configure(configs: ServiceConfig[]): { success: boolean } {
-    // Sort by priority (lower = higher priority)
-    configs.sort((a, b) => (a.priority || 0) - (b.priority || 0));
-
-    if (configs.length > 0) {
-      this.primaryService = new this.ServiceClass(configs[0]);
+    primaryService;
+    fallbackServices;
+    configured;
+    ServiceClass;
+    constructor(ServiceClass = EmbeddingService) {
+        this.primaryService = null;
+        this.fallbackServices = [];
+        this.configured = false;
+        this.ServiceClass = ServiceClass;
     }
-
-    if (configs.length > 1) {
-      this.fallbackServices = configs
-        .slice(1)
-        .map((c) => new this.ServiceClass(c));
-    }
-
-    this.configured = true;
-    return { success: true };
-  }
-
-  /**
-   * Initialize all configured services
-   * @returns {Promise<Object>} Initialization status
-   */
-  async init(): Promise<InitResult> {
-    if (!this.configured) {
-      throw new ConfigurationError(
-        "EmbeddingFactory not configured. Call configure() first.",
-      );
+    /**
+     * Configure embedding services with fallback chain
+     * @param {Array} configs - Array of { modelType, modelName, priority, apiKey }
+     * @returns {Object} Success status
+     */
+    configure(configs) {
+        // Sort by priority (lower = higher priority)
+        configs.sort((a, b) => (a.priority || 0) - (b.priority || 0));
+        if (configs.length > 0) {
+            this.primaryService = new this.ServiceClass(configs[0]);
+        }
+        if (configs.length > 1) {
+            this.fallbackServices = configs
+                .slice(1)
+                .map((c) => new this.ServiceClass(c));
+        }
+        this.configured = true;
+        return { success: true };
     }
-
-    // Initialize primary service
-    if (this.primaryService && !this.primaryService.initialized) {
-      await this.primaryService.init();
+    /**
+     * Initialize all configured services
+     * @returns {Promise<Object>} Initialization status
+     */
+    async init() {
+        if (!this.configured) {
+            throw new ConfigurationError("EmbeddingFactory not configured. Call configure() first.");
+        }
+        // Initialize primary service
+        if (this.primaryService && !this.primaryService.initialized) {
+            await this.primaryService.init();
+        }
+        // Initialize fallback services lazily (on first use)
+        return {
+            success: true,
+            primary: this.primaryService ? this.primaryService.modelName : null,
+            fallbacks: this.fallbackServices.map((s) => s.modelName),
+        };
     }
-
-    // Initialize fallback services lazily (on first use)
-    return {
-      success: true,
-      primary: this.primaryService ? this.primaryService.modelName : null,
-      fallbacks: this.fallbackServices.map((s) => s.modelName),
-    };
-  }
-
-  /**
-   * Generate embedding with automatic fallback
-   * @param {string} text - Text to embed
-   * @param {Object} options - Options
-   * @returns {Promise<number[]>} Embedding vector
-   */
-  async embed(text: string, options: any = {}): Promise<number[]> {
-    if (!this.configured || !this.primaryService) {
-      throw new ConfigurationError("EmbeddingFactory not configured");
+    /**
+     * Generate embedding with automatic fallback
+     * @param {string} text - Text to embed
+     * @param {Object} options - Options
+     * @returns {Promise<number[]>} Embedding vector
+     */
+    async embed(text, options = {}) {
+        if (!this.configured || !this.primaryService) {
+            throw new ConfigurationError("EmbeddingFactory not configured");
+        }
+        // Try primary service
+        try {
+            if (!this.primaryService.initialized) {
+                await this.primaryService.init();
+            }
+            return await this.primaryService.embed(text, options);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.warn({ err: error, primaryService: this.primaryService?.modelName }, "Primary service failed");
+            // Try fallback services in order
+            for (const fallback of this.fallbackServices) {
+                try {
+                    if (!fallback.initialized) {
+                        await fallback.init();
+                    }
+                    logger.info({ fallbackModel: fallback.modelName }, "Using fallback service");
+                    return await fallback.embed(text, options);
+                }
+                catch (fallbackError) {
+                    logger.warn({ err: fallbackError, fallbackModel: fallback.modelName }, "Fallback service failed");
+                }
+            }
+            throw new EmbeddingError("All embedding services failed", {
+                primaryError: errorMessage,
+                fallbackCount: this.fallbackServices.length,
+            });
+        }
     }
-
-    // Try primary service
-    try {
-      if (!this.primaryService.initialized) {
-        await this.primaryService.init();
-      }
-      return await this.primaryService.embed(text, options);
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      logger.warn(
-        { err: error, primaryService: this.primaryService?.modelName },
-        "Primary service failed",
-      );
-
-      // Try fallback services in order
-      for (const fallback of this.fallbackServices) {
+    /**
+     * Generate embeddings for batch of texts
+     * @param {string[]} texts - Texts to embed
+     * @param {Object} options - Options
+     * @returns {Promise<number[][]>} Array of embedding vectors
+     */
+    async embedBatch(texts, options = {}) {
+        if (!this.configured || !this.primaryService) {
+            throw new ConfigurationError("EmbeddingFactory not configured");
+        }
+        // Try primary service
         try {
-          if (!fallback.initialized) {
-            await fallback.init();
-          }
-          logger.info(
-            { fallbackModel: fallback.modelName },
-            "Using fallback service",
-          );
-          return await fallback.embed(text, options);
-        } catch (fallbackError) {
-          logger.warn(
-            { err: fallbackError, fallbackModel: fallback.modelName },
-            "Fallback service failed",
-          );
+            if (!this.primaryService.initialized) {
+                await this.primaryService.init();
+            }
+            return await this.primaryService.embedBatch(texts, options);
+        }
+        catch (error) {
+            logger.warn({
+                err: error,
+                primaryService: this.primaryService?.modelName,
+                batchSize: texts.length,
+            }, "Primary batch embedding failed, falling back to individual embeddings");
+            // Fallback to individual embedding with fallback services
+            const results = [];
+            for (const text of texts) {
+                results.push(await this.embed(text, options));
+            }
+            return results;
         }
-      }
-
-      throw new EmbeddingError("All embedding services failed", {
-        primaryError: errorMessage,
-        fallbackCount: this.fallbackServices.length,
-      });
     }
-  }
-
-  /**
-   * Generate embeddings for batch of texts
-   * @param {string[]} texts - Texts to embed
-   * @param {Object} options - Options
-   * @returns {Promise<number[][]>} Array of embedding vectors
-   */
-  async embedBatch(texts: string[], options: any = {}): Promise<number[][]> {
-    if (!this.configured || !this.primaryService) {
-      throw new ConfigurationError("EmbeddingFactory not configured");
+    /**
+     * Get factory statistics
+     * @returns {Object} Statistics
+     */
+    getStats() {
+        const stats = {
+            configured: this.configured,
+            primary: this.primaryService?.getStats() || null,
+            fallbacks: this.fallbackServices.map((s) => s.getStats()),
+        };
+        return stats;
     }
-
-    // Try primary service
-    try {
-      if (!this.primaryService.initialized) {
-        await this.primaryService.init();
-      }
-      return await this.primaryService.embedBatch(texts, options);
-    } catch (error) {
-      logger.warn(
-        {
-          err: error,
-          primaryService: this.primaryService?.modelName,
-          batchSize: texts.length,
-        },
-        "Primary batch embedding failed, falling back to individual embeddings",
-      );
-      // Fallback to individual embedding with fallback services
-      const results: number[][] = [];
-      for (const text of texts) {
-        results.push(await this.embed(text, options));
-      }
-      return results;
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        this.primaryService?.clearCache();
+        this.fallbackServices.forEach((s) => s.clearCache());
     }
-  }
-
-  /**
-   * Get factory statistics
-   * @returns {Object} Statistics
-   */
-  getStats(): FactoryStats {
-    const stats = {
-      configured: this.configured,
-      primary: this.primaryService?.getStats() || null,
-      fallbacks: this.fallbackServices.map((s) => s.getStats()),
-    };
-    return stats;
-  }
-
-  /**
-   * Clear all caches
-   */
-  clearCache(): void {
-    this.primaryService?.clearCache();
-    this.fallbackServices.forEach((s) => s.clearCache());
-  }
 }
-
 export default EmbeddingFactory;

package/lib/memory/embeddings/index.js

@@ -1,2 +1,3 @@
+// @ts-nocheck
 export { default as EmbeddingService } from "./service.js";
 export { default as EmbeddingFactory } from "./factory.js";

package/lib/memory/embeddings/index.ts

@@ -1,2 +1,3 @@
+// @ts-nocheck
 export { default as EmbeddingService } from "./service.js";
 export { default as EmbeddingFactory } from "./factory.js";

package/lib/memory/embeddings/service.d.ts

@@ -1,69 +1,25 @@
-/**
- * EmbeddingService - Multi-provider embedding generation service
- *
- * Supports:
- * - Local models: Xenova/Transformers.js (ONNX runtime)
- * - Ollama: Local Ollama embeddings API
- * - API models: OpenAI, Cohere
- *
- * Implements TDD for Phase 3, Task 3.1 - Embedding Service Architecture
- */
-/**
- * Service configuration interface
- */
-export interface ServiceConfig {
-    modelType?: "local" | "ollama" | "openai" | "cohere";
-    modelName?: string;
-    baseUrl?: string;
-    dimension?: number;
-    batchSize?: number;
-    normalize?: boolean;
-    cacheMaxSize?: number;
-    apiKey?: string;
-    priority?: number;
-}
-export interface ServiceStats {
-    modelType: string;
-    modelName: string;
-    dimension: number;
-    initialized: boolean;
-    totalEmbeddings: number;
-    cacheHits: number;
-    cacheMisses: number;
-    cacheSize: number;
-    cacheMaxSize: number;
-    cacheHitRate: number;
-    batchCount: number;
-    batchSize: number;
-    normalize: boolean;
-}
 /**
  * EmbeddingService provides a unified interface for generating text embeddings
  * using multiple backend providers (local ONNX models or cloud APIs).
  */
 export declare class EmbeddingService {
-    modelType: string;
-    modelName: string;
-    baseUrl: string;
-    dimension: number;
-    batchSize: number;
-    normalize: boolean;
-    apiKey?: string;
+    modelType: any;
+    modelName: any;
+    baseUrl: any;
+    dimension: any;
+    batchSize: any;
+    normalize: any;
+    apiKey: any;
     model: any;
-    cache: Map<string, number[]>;
-    cacheMaxSize: number;
-    initialized: boolean;
-    stats: {
-        totalEmbeddings: number;
-        cacheHits: number;
-        cacheMisses: number;
-        batchCount: number;
-    };
+    cache: any;
+    cacheMaxSize: any;
+    initialized: any;
+    stats: any;
     /**
      * Create a new EmbeddingService instance
      * @param {Object} [config={}] - Configuration options
      */
-    constructor(config?: ServiceConfig);
+    constructor(config?: {});
     /**
      * Initialize the embedding model
      * Loads the model based on modelType (local, ollama, openai, cohere)
@@ -75,14 +31,14 @@ export declare class EmbeddingService {
      * @param {Object} options - Options for embedding generation
      * @returns {Promise<number[]>} Embedding vector
      */
-    embed(text: string, _options?: any): Promise<number[]>;
+    embed(text: any, _options?: {}): Promise<any>;
     /**
      * Generate embeddings for a batch of texts
      * @param {string[]} texts - Array of texts to embed
      * @param {Object} options - Options for embedding generation
      * @returns {Promise<number[][]>} Array of embedding vectors
      */
-    embedBatch(texts: string[], _options?: any): Promise<number[][]>;
+    embedBatch(texts: any, _options?: {}): Promise<any[]>;
     /**
      * Initialize local ONNX model using Xenova/Transformers.js
      * @private
@@ -110,48 +66,62 @@ export declare class EmbeddingService {
      * @returns {Promise<number[]>} Embedding vector
      * @private
      */
-    _embedLocal(text: string): Promise<number[]>;
+    _embedLocal(text: any): Promise<unknown[]>;
     /**
      * Generate embedding using Ollama API
      * @param {string} text - Text to embed
      * @returns {Promise<number[]>} Embedding vector
      * @private
      */
-    _embedOllama(text: string): Promise<number[]>;
+    _embedOllama(text: any): Promise<any>;
     /**
      * Generate embedding using OpenAI API
      * @param {string} text - Text to embed
      * @returns {Promise<number[]>} Embedding vector
      * @private
      */
-    _embedOpenAI(text: string): Promise<number[]>;
+    _embedOpenAI(text: any): Promise<any>;
     /**
      * Generate embedding using Cohere API
      * @param {string} text - Text to embed
      * @returns {Promise<number[]>} Embedding vector
      * @private
      */
-    _embedCohere(text: string): Promise<number[]>;
+    _embedCohere(text: any): Promise<any>;
     /**
      * Normalize vector to unit length
      * @param {number[]} vector - Vector to normalize
      * @returns {number[]} Normalized vector
      * @private
      */
-    _normalize(vector: number[]): number[];
+    _normalize(vector: any): any;
     /**
      * Generate cache key from text
      * @param {string} text - Text to generate key from
      * @returns {string} Cache key
      * @private
      */
-    _getCacheKey(text: string): string;
-    _setCache(key: string, value: number[]): void;
+    _getCacheKey(text: any): string;
+    _setCache(key: any, value: any): void;
     /**
      * Get service statistics
      * @returns {Object} Statistics object
      */
-    getStats(): ServiceStats;
+    getStats(): {
+        modelType: any;
+        modelName: any;
+        dimension: any;
+        initialized: any;
+        totalEmbeddings: any;
+        cacheHits: any;
+        cacheMisses: any;
+        cacheSize: any;
+        cacheMaxSize: any;
+        cacheHitRate: number;
+        batchCount: any;
+        batchSize: any;
+        normalize: any;
+    };
     /**
      * Clear the embedding cache
      */

package/lib/memory/embeddings/service.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * EmbeddingService - Multi-provider embedding generation service
  *