@yamo/memory-mesh 3.0.0 → 3.0.1

package/lib/memory/memory-translator.d.ts

@@ -1,11 +1,6 @@
 /**
  * MemoryTranslator - Converts memories to YAMO agent format
  */
-export interface TranslationOptions {
-    mode?: string;
-    includeMetadata?: boolean;
-    maxContentLength?: number;
-}
 export declare class MemoryTranslator {
     #private;
     /**
@@ -14,6 +9,6 @@ export declare class MemoryTranslator {
      * @param {TranslationOptions} options - Translation options
      * @returns {string} Formatted YAMO agent context
      */
-    static toYAMOContext(memories: any[], options?: TranslationOptions): string;
+    static toYAMOContext(memories: any, options?: {}): string;
 }
 export default MemoryTranslator;

package/lib/memory/memory-translator.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * MemoryTranslator - Converts memories to YAMO agent format
  */

package/lib/memory/memory-translator.ts

@@ -1,50 +1,33 @@
+// @ts-nocheck
 /**
  * MemoryTranslator - Converts memories to YAMO agent format
  */
-
-export interface TranslationOptions {
-  mode?: string;
-  includeMetadata?: boolean;
-  maxContentLength?: number;
-}
-
 export class MemoryTranslator {
-  /**
-   * Translate memories into YAMO agent context
-   * @param {Array<any>} memories - Retrieved memories
-   * @param {TranslationOptions} options - Translation options
-   * @returns {string} Formatted YAMO agent context
-   */
-  static toYAMOContext(
-    memories: any[],
-    options: TranslationOptions = {},
-  ): string {
-    if (!memories || memories.length === 0) {
-      return "";
+    /**
+     * Translate memories into YAMO agent context
+     * @param {Array<any>} memories - Retrieved memories
+     * @param {TranslationOptions} options - Translation options
+     * @returns {string} Formatted YAMO agent context
+     */
+    static toYAMOContext(memories, options = {}) {
+        if (!memories || memories.length === 0) {
+            return "";
+        }
+        const { mode = "background_context", includeMetadata = true, maxContentLength = 500, } = options;
+        const header = this.#buildHeader(memories, mode);
+        const memoriesSection = this.#buildMemoriesSection(memories, {
+            includeMetadata,
+            maxContentLength,
+        });
+        const footer = this.#buildFooter(memories);
+        return `${header}\n\n${memoriesSection}\n\n${footer}`;
     }
-
-    const {
-      mode = "background_context",
-      includeMetadata = true,
-      maxContentLength = 500,
-    } = options;
-
-    const header = this.#buildHeader(memories, mode);
-    const memoriesSection = this.#buildMemoriesSection(memories, {
-      includeMetadata,
-      maxContentLength,
-    });
-    const footer = this.#buildFooter(memories);
-
-    return `${header}\n\n${memoriesSection}\n\n${footer}`;
-  }
-
-  /**
-   * Build YAMO agent header with operational context
-   * @private
-   */
-  static #buildHeader(memories: any[], mode: string): string {
-    return `[AGENT INVOCATION: MemoryRecall]
+    /**
+     * Build YAMO agent header with operational context
+     * @private
+     */
+    static #buildHeader(memories, mode) {
+        return `[AGENT INVOCATION: MemoryRecall]
 agent: MemoryRecall;
 role: context_provider;
 mode: ${mode};
@@ -57,102 +40,87 @@ These are memories retrieved from past interactions.
 - Memories provide background but current query takes precedence
 - Information may be outdated; verify if critical
 - Relevance and importance scores indicate reliability`;
-  }
-
-  /**
-   * Build memories section with structured entries
-   * @private
-   */
-  static #buildMemoriesSection(memories: any[], options: any): string {
-    const sections = memories.map((memory, idx) => {
-      return this.#formatMemory(memory, idx, options);
-    });
-
-    return `[RETRIEVED MEMORIES]\n${sections.join("\n\n---\n\n")}`;
-  }
-
-  /**
-   * Format individual memory with metadata
-   * @private
-   */
-  static #formatMemory(memory: any, index: number, options: any): string {
-    const { includeMetadata, maxContentLength } = options;
-
-    // Truncate content if too long
-    let content = memory.content;
-    if (content.length > maxContentLength) {
-      content = `${content.substring(0, maxContentLength)}... [truncated]`;
     }
-
-    // Build memory entry
-    let entry = `[MEMORY_ENTRY_${index + 1}]
+    /**
+     * Build memories section with structured entries
+     * @private
+     */
+    static #buildMemoriesSection(memories, options) {
+        const sections = memories.map((memory, idx) => {
+            return this.#formatMemory(memory, idx, options);
+        });
+        return `[RETRIEVED MEMORIES]\n${sections.join("\n\n---\n\n")}`;
+    }
+    /**
+     * Format individual memory with metadata
+     * @private
+     */
+    static #formatMemory(memory, index, options) {
+        const { includeMetadata, maxContentLength } = options;
+        // Truncate content if too long
+        let content = memory.content;
+        if (content.length > maxContentLength) {
+            content = `${content.substring(0, maxContentLength)}... [truncated]`;
+        }
+        // Build memory entry
+        let entry = `[MEMORY_ENTRY_${index + 1}]
 type: ${memory.memoryType || "global"};
 relevance: ${memory.score?.toFixed(2) || "N/A"};
 importance: ${memory.importanceScore?.toFixed(2) || "N/A"};
 timestamp: ${this.#formatTimestamp(memory.created_at)}`;
-
-    // Add optional metadata
-    if (includeMetadata && memory.metadata) {
-      const meta =
-        typeof memory.metadata === "string"
-          ? JSON.parse(memory.metadata)
-          : memory.metadata;
-
-      if (meta.interaction_type) {
-        entry += `\ninteraction_type: ${meta.interaction_type}`;
-      }
-      if (meta.tags?.length > 0) {
-        entry += `\ntags: ${meta.tags.join(", ")}`;
-      }
+        // Add optional metadata
+        if (includeMetadata && memory.metadata) {
+            const meta = typeof memory.metadata === "string"
+                ? JSON.parse(memory.metadata)
+                : memory.metadata;
+            if (meta.interaction_type) {
+                entry += `\ninteraction_type: ${meta.interaction_type}`;
+            }
+            if (meta.tags?.length > 0) {
+                entry += `\ntags: ${meta.tags.join(", ")}`;
+            }
+        }
+        // Sanitize content to prevent role-confusion
+        // Replaces [USER] and [ASSISTANT] with labels that clearly indicate historical status
+        const sanitizedContent = content
+            .replace(/\[USER\]/g, "[PAST_USER_LOG]")
+            .replace(/\[ASSISTANT\]/g, "[PAST_ASSISTANT_LOG]");
+        // Add content
+        entry += `\n\n[HISTORICAL_RECORD_CONTENT]\n${sanitizedContent}`;
+        return entry;
     }
-
-    // Sanitize content to prevent role-confusion
-    // Replaces [USER] and [ASSISTANT] with labels that clearly indicate historical status
-    const sanitizedContent = content
-      .replace(/\[USER\]/g, "[PAST_USER_LOG]")
-      .replace(/\[ASSISTANT\]/g, "[PAST_ASSISTANT_LOG]");
-
-    // Add content
-    entry += `\n\n[HISTORICAL_RECORD_CONTENT]\n${sanitizedContent}`;
-
-    return entry;
-  }
-
-  /**
-   * Build footer with usage guidance
-   * @private
-   */
-  static #buildFooter(memories: any[]): string {
-    return `[END MEMORY RECALL]
+    /**
+     * Build footer with usage guidance
+     * @private
+     */
+    static #buildFooter(memories) {
+        return `[END MEMORY RECALL]
 Total memories provided: ${memories.length}
 Usage: Reference these memories when relevant to the current query.
 Priority: Current user query > Recent memories > Older memories`;
-  }
-
-  /**
-   * Format timestamp as relative time
-   * @private
-   */
-  static #formatTimestamp(timestamp: any): string {
-    const date = new Date(timestamp);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-
-    if (diffDays === 0) {
-      return "today";
     }
-    if (diffDays === 1) {
-      return "yesterday";
+    /**
+     * Format timestamp as relative time
+     * @private
+     */
+    static #formatTimestamp(timestamp) {
+        const date = new Date(timestamp);
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffDays === 0) {
+            return "today";
+        }
+        if (diffDays === 1) {
+            return "yesterday";
+        }
+        if (diffDays < 7) {
+            return `${diffDays} days ago`;
+        }
+        if (diffDays < 30) {
+            return `${Math.floor(diffDays / 7)} weeks ago`;
+        }
+        return date.toLocaleDateString();
     }
-    if (diffDays < 7) {
-      return `${diffDays} days ago`;
-    }
-    if (diffDays < 30) {
-      return `${Math.floor(diffDays / 7)} weeks ago`;
-    }
-    return date.toLocaleDateString();
-  }
 }
-
 export default MemoryTranslator;

package/lib/memory/schema.d.ts

@@ -8,7 +8,6 @@
  * - text-embedding-3-small: 1536 dimensions
  */
 import * as arrow from "apache-arrow";
-import * as lancedb from "@lancedb/lancedb";
 /**
  * Default vector dimension (all-MiniLM-L6-v2)
  */
@@ -16,38 +15,48 @@ export declare const DEFAULT_VECTOR_DIMENSION = 384;
 /**
  * Common embedding model dimensions
  */
-export declare const EMBEDDING_DIMENSIONS: Record<string, number>;
+export declare const EMBEDDING_DIMENSIONS: {
+    "Xenova/all-MiniLM-L6-v2": number;
+    "Xenova/all-mpnet-base-v2": number;
+    "Xenova/distiluse-base-multilingual-cased-v1": number;
+    "sentence-transformers/all-MiniLM-L6-v2": number;
+    "sentence-transformers/all-mpnet-base-v2": number;
+    "openai/text-embedding-3-small": number;
+    "openai/text-embedding-3-large": number;
+    "cohere/embed-english-light-v3.0": number;
+    "cohere/embed-english-v3.0": number;
+};
 /**
  * Get dimension for a given embedding model
  * @param {string} modelName - Embedding model name or path
  * @returns {number} Vector dimension
  */
-export declare function getEmbeddingDimension(modelName?: string): number;
+export declare function getEmbeddingDimension(modelName: any): any;
 /**
  * Create a memory schema with a specific vector dimension
  * @param {number} vectorDim - Vector dimension (e.g., 384, 768, 1536)
  * @returns {arrow.Schema} Arrow schema with specified dimension
  */
-export declare function createMemorySchema(vectorDim?: number): arrow.Schema;
+export declare function createMemorySchema(vectorDim?: number): arrow.Schema<any>;
 /**
  * Create V2 memory schema with automatic recall fields
  * All new fields are nullable for backward compatibility
  * @param {number} vectorDim - Vector dimension (e.g., 384, 768, 1536)
  * @returns {arrow.Schema} Arrow schema with V2 fields
  */
-export declare function createMemorySchemaV2(vectorDim?: number): arrow.Schema;
+export declare function createMemorySchemaV2(vectorDim?: number): arrow.Schema<any>;
 /**
  * Create schema for synthesized skills (Recursive Skill Synthesis)
  * @param {number} vectorDim - Vector dimension for intent embedding
  * @returns {arrow.Schema} Arrow schema
  */
-export declare function createSynthesizedSkillSchema(vectorDim?: number): arrow.Schema;
+export declare function createSynthesizedSkillSchema(vectorDim?: number): arrow.Schema<any>;
 /**
  * Check if a table is using V2 schema
  * @param {arrow.Schema} schema - Table schema to check
  * @returns {boolean} True if V2 schema detected
  */
-export declare function isSchemaV2(schema: arrow.Schema): boolean;
+export declare function isSchemaV2(schema: any): any;
 /**
  * Memory table schema using Apache Arrow format (default 384 dimensions)
  * @deprecated Use createMemorySchema(vectorDim) for dynamic dimensions
@@ -76,7 +85,7 @@ export declare const INDEX_CONFIG: {
  * @throws {Error} If table creation fails
  * @deprecated Use createMemoryTableWithDimension() for dynamic dimensions
  */
-export declare function createMemoryTable(db: lancedb.Connection, tableName?: string): Promise<lancedb.Table>;
+export declare function createMemoryTable(db: any, tableName?: string): Promise<any>;
 /**
  * Creates a memory table in LanceDB with a specific vector dimension
  * @param {lancedb.Connection} db - LanceDB connection
@@ -85,7 +94,7 @@ export declare function createMemoryTable(db: lancedb.Connection, tableName?: st
  * @returns {Promise<lancedb.Table>} The created or opened table
  * @throws {Error} If table creation fails
  */
-export declare function createMemoryTableWithDimension(db: lancedb.Connection, tableName: string, vectorDim: number): Promise<lancedb.Table>;
+export declare function createMemoryTableWithDimension(db: any, tableName: any, vectorDim: any): Promise<any>;
 declare const _default: {
     MEMORY_SCHEMA: arrow.Schema<any>;
     INDEX_CONFIG: {
@@ -106,6 +115,16 @@ declare const _default: {
     isSchemaV2: typeof isSchemaV2;
     getEmbeddingDimension: typeof getEmbeddingDimension;
     DEFAULT_VECTOR_DIMENSION: number;
-    EMBEDDING_DIMENSIONS: Record<string, number>;
+    EMBEDDING_DIMENSIONS: {
+        "Xenova/all-MiniLM-L6-v2": number;
+        "Xenova/all-mpnet-base-v2": number;
+        "Xenova/distiluse-base-multilingual-cased-v1": number;
+        "sentence-transformers/all-MiniLM-L6-v2": number;
+        "sentence-transformers/all-mpnet-base-v2": number;
+        "openai/text-embedding-3-small": number;
+        "openai/text-embedding-3-large": number;
+        "cohere/embed-english-light-v3.0": number;
+        "cohere/embed-english-v3.0": number;
+    };
 };
 export default _default;

package/lib/memory/schema.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * LanceDB Schema Definitions for MemoryManager
  * Uses Apache Arrow Schema format for LanceDB JavaScript SDK