@yamo/memory-mesh 3.0.0 → 3.0.1

package/lib/yamo/emitter.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * YAMO Emitter - Constructs structured YAMO blocks for auditability
  *
@@ -8,64 +9,20 @@
  *
  * Reference: Hindsight project's yamo_integration.py
  */
-
-export interface ReflectBlockParams {
-  topic?: string;
-  memoryCount: number;
-  agentId?: string;
-  reflection: string;
-  confidence?: number;
-}
-
-export interface RetainBlockParams {
-  content: string;
-  metadata?: any;
-  id: string;
-  agentId?: string;
-  memoryType?: string;
-}
-
-export interface RecallBlockParams {
-  query: string;
-  resultCount: number;
-  limit?: number;
-  agentId?: string;
-  searchType?: string;
-}
-
-export interface DeleteBlockParams {
-  id: string;
-  agentId?: string;
-  reason?: string;
-}
-
-export interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-}
-
 /**
  * YamoEmitter class for building YAMO protocol blocks
  * YAMO (Yet Another Multi-agent Orchestration) blocks provide
  * structured reasoning traces for AI agent operations.
  */
 export class YamoEmitter {
-  /**
-   * Build a YAMO block for reflect operation
-   * Reflect operations synthesize insights from existing memories
-   */
-  static buildReflectBlock(params: ReflectBlockParams): string {
-    const {
-      topic,
-      memoryCount,
-      agentId = "default",
-      reflection,
-      confidence = 0.8,
-    } = params;
-
-    const timestamp = new Date().toISOString();
-
-    return `agent: MemoryMesh_${agentId};
+    /**
+     * Build a YAMO block for reflect operation
+     * Reflect operations synthesize insights from existing memories
+     */
+    static buildReflectBlock(params) {
+        const { topic, memoryCount, agentId = "default", reflection, confidence = 0.8, } = params;
+        const timestamp = new Date().toISOString();
+        return `agent: MemoryMesh_${agentId};
 intent: synthesize_insights_from_context;
 context:
   topic;${topic || "general"};
@@ -84,29 +41,18 @@ meta:
 log: reflection_generated;timestamp;${timestamp};memories;${memoryCount};
 handoff: End;
 `;
-  }
-
-  /**
-   * Build a YAMO block for retain (add) operation
-   * Retain operations store new memories into the system
-   */
-  static buildRetainBlock(params: RetainBlockParams): string {
-    const {
-      content,
-      metadata: _metadata = {},
-      id,
-      agentId = "default",
-      memoryType = "event",
-    } = params;
-
-    const timestamp = new Date().toISOString();
-    const contentPreview =
-      content.length > 100 ? `${content.substring(0, 100)}...` : content;
-
-    // Escape semicolons in content for YAMO format
-    const escapedContent = contentPreview.replace(/;/g, ",");
-
-    return `agent: MemoryMesh_${agentId};
+    }
+    /**
+     * Build a YAMO block for retain (add) operation
+     * Retain operations store new memories into the system
+     */
+    static buildRetainBlock(params) {
+        const { content, metadata: _metadata = {}, id, agentId = "default", memoryType = "event", } = params;
+        const timestamp = new Date().toISOString();
+        const contentPreview = content.length > 100 ? `${content.substring(0, 100)}...` : content;
+        // Escape semicolons in content for YAMO format
+        const escapedContent = contentPreview.replace(/;/g, ",");
+        return `agent: MemoryMesh_${agentId};
 intent: store_memory_for_future_retrieval;
 context:
   memory_id;${id};
@@ -126,26 +72,16 @@ meta:
 log: memory_retained;timestamp;${timestamp};id;${id};type;${memoryType};
 handoff: End;
 `;
-  }
-
-  /**
-   * Build a YAMO block for recall (search) operation
-   * Recall operations retrieve memories based on semantic similarity
-   */
-  static buildRecallBlock(params: RecallBlockParams): string {
-    const {
-      query,
-      resultCount,
-      limit = 10,
-      agentId = "default",
-      searchType = "semantic",
-    } = params;
-
-    const timestamp = new Date().toISOString();
-    const recallRatio =
-      resultCount > 0 ? (resultCount / limit).toFixed(2) : "0.00";
-
-    return `agent: MemoryMesh_${agentId};
+    }
+    /**
+     * Build a YAMO block for recall (search) operation
+     * Recall operations retrieve memories based on semantic similarity
+     */
+    static buildRecallBlock(params) {
+        const { query, resultCount, limit = 10, agentId = "default", searchType = "semantic", } = params;
+        const timestamp = new Date().toISOString();
+        const recallRatio = resultCount > 0 ? (resultCount / limit).toFixed(2) : "0.00";
+        return `agent: MemoryMesh_${agentId};
 intent: retrieve_relevant_memories;
 context:
   query;${query};
@@ -165,18 +101,15 @@ meta:
 log: memory_recalled;timestamp;${timestamp};results;${resultCount};query;${query};
 handoff: End;
 `;
-  }
-
-  /**
-   * Build a YAMO block for delete operation (optional)
-   * Delete operations remove memories from the system
-   */
-  static buildDeleteBlock(params: DeleteBlockParams): string {
-    const { id, agentId = "default", reason = "user_request" } = params;
-
-    const timestamp = new Date().toISOString();
-
-    return `agent: MemoryMesh_${agentId};
+    }
+    /**
+     * Build a YAMO block for delete operation (optional)
+     * Delete operations remove memories from the system
+     */
+    static buildDeleteBlock(params) {
+        const { id, agentId = "default", reason = "user_request" } = params;
+        const timestamp = new Date().toISOString();
+        return `agent: MemoryMesh_${agentId};
 intent: remove_memory_from_storage;
 context:
   memory_id;${id};
@@ -194,56 +127,45 @@ meta:
 log: memory_deleted;timestamp;${timestamp};id;${id};
 handoff: End;
 `;
-  }
-
-  /**
-   * Validate a YAMO block structure
-   * Checks for required sections and proper formatting
-   */
-  static validateBlock(yamoBlock: string): ValidationResult {
-    const errors: string[] = [];
-
-    // Check for required sections
-    const requiredSections = [
-      "agent:",
-      "intent:",
-      "context:",
-      "output:",
-      "log:",
-    ];
-    for (const section of requiredSections) {
-      if (!yamoBlock.includes(section)) {
-        errors.push(`Missing required section: ${section}`);
-      }
     }
-
-    // Check for semicolon termination
-    const lines = yamoBlock.split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (
-        trimmed.length > 0 &&
-        !trimmed.startsWith("//") &&
-        !trimmed.endsWith(";")
-      ) {
-        // Allow empty lines and comments
-        if (
-          trimmed &&
-          !trimmed.startsWith("agent:") &&
-          !trimmed.startsWith("handoff:")
-        ) {
-          errors.push(
-            `Line not semicolon-terminated: ${trimmed.substring(0, 50)}`,
-          );
+    /**
+     * Validate a YAMO block structure
+     * Checks for required sections and proper formatting
+     */
+    static validateBlock(yamoBlock) {
+        const errors = [];
+        // Check for required sections
+        const requiredSections = [
+            "agent:",
+            "intent:",
+            "context:",
+            "output:",
+            "log:",
+        ];
+        for (const section of requiredSections) {
+            if (!yamoBlock.includes(section)) {
+                errors.push(`Missing required section: ${section}`);
+            }
+        }
+        // Check for semicolon termination
+        const lines = yamoBlock.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.length > 0 &&
+                !trimmed.startsWith("//") &&
+                !trimmed.endsWith(";")) {
+                // Allow empty lines and comments
+                if (trimmed &&
+                    !trimmed.startsWith("agent:") &&
+                    !trimmed.startsWith("handoff:")) {
+                    errors.push(`Line not semicolon-terminated: ${trimmed.substring(0, 50)}`);
+                }
+            }
         }
-      }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
     }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-    };
-  }
 }
-
 export default YamoEmitter;

package/lib/yamo/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * YAMO Module - YAMO Protocol support for yamo-memory-mesh
+ * Exports YAMO block construction, validation, and schema utilities
+ */
+export { YamoEmitter } from './emitter.js';
+export * from './schema.js';
+declare const _default: {
+    YamoEmitter: typeof import("./emitter.js").YamoEmitter;
+    createYamoSchema: typeof import("./schema.js").createYamoSchema;
+    createYamoTable: typeof import("./schema.js").createYamoTable;
+    validateYamoRecord: typeof import("./schema.js").validateYamoRecord;
+    generateYamoId: typeof import("./schema.js").generateYamoId;
+};
+export default _default;

package/lib/yamo/index.js

@@ -0,0 +1,14 @@
+// @ts-nocheck
+/**
+ * YAMO Module - YAMO Protocol support for yamo-memory-mesh
+ * Exports YAMO block construction, validation, and schema utilities
+ */
+export { YamoEmitter } from './emitter.js';
+export * from './schema.js';
+export default {
+    YamoEmitter: (await import('./emitter.js')).YamoEmitter,
+    createYamoSchema: (await import('./schema.js')).createYamoSchema,
+    createYamoTable: (await import('./schema.js')).createYamoTable,
+    validateYamoRecord: (await import('./schema.js')).validateYamoRecord,
+    generateYamoId: (await import('./schema.js')).generateYamoId
+};

package/lib/yamo/index.ts

@@ -0,0 +1,16 @@
+// @ts-nocheck
+/**
+ * YAMO Module - YAMO Protocol support for yamo-memory-mesh
+ * Exports YAMO block construction, validation, and schema utilities
+ */
+
+export { YamoEmitter } from './emitter.js';
+export * from './schema.js';
+
+export default {
+  YamoEmitter: (await import('./emitter.js')).YamoEmitter,
+  createYamoSchema: (await import('./schema.js')).createYamoSchema,
+  createYamoTable: (await import('./schema.js')).createYamoTable,
+  validateYamoRecord: (await import('./schema.js')).validateYamoRecord,
+  generateYamoId: (await import('./schema.js')).generateYamoId
+};

package/lib/yamo/schema.d.ts

@@ -6,13 +6,12 @@
  * YAMO blocks provide audit trail for all memory operations.
  */
 import * as arrow from "apache-arrow";
-import * as lancedb from "@lancedb/lancedb";
 /**
  * Create YAMO blocks table schema
  * Defines the structure for storing YAMO protocol blocks
  * @returns {arrow.Schema} Arrow schema for YAMO blocks
  */
-export declare function createYamoSchema(): arrow.Schema;
+export declare function createYamoSchema(): arrow.Schema<any>;
 /**
  * Create YAMO blocks table in LanceDB
  * Creates the table if it doesn't exist, opens it if it does
@@ -22,16 +21,15 @@ export declare function createYamoSchema(): arrow.Schema;
  * @returns {Promise<lancedb.Table>} The created or opened table
  * @throws {Error} If table creation fails
  */
-export declare function createYamoTable(db: lancedb.Connection, tableName?: string): Promise<lancedb.Table>;
-export interface YamoRecordValidationResult {
-    valid: boolean;
-    errors: string[];
-}
+export declare function createYamoTable(db: any, tableName?: string): Promise<any>;
 /**
  * Validate a YAMO block record before insertion
  * Checks for required fields and valid values
  */
-export declare function validateYamoRecord(record: any): YamoRecordValidationResult;
+export declare function validateYamoRecord(record: any): {
+    valid: boolean;
+    errors: any[];
+};
 /**
  * Generate a YAMO block ID
  * Creates a unique ID for a YAMO block
@@ -39,7 +37,7 @@ export declare function validateYamoRecord(record: any): YamoRecordValidationRes
  * @param {string} operationType - Type of operation
  * @returns {string} Generated YAMO block ID
  */
-export declare function generateYamoId(operationType: string): string;
+export declare function generateYamoId(operationType: any): string;
 /**
  * Check if a table uses YAMO schema
  * Detects if a table has the YAMO block schema structure
@@ -47,7 +45,7 @@ export declare function generateYamoId(operationType: string): string;
  * @param {arrow.Schema} schema - Table schema to check
  * @returns {boolean} True if YAMO schema detected
  */
-export declare function isYamoSchema(schema: arrow.Schema): boolean;
+export declare function isYamoSchema(schema: any): any;
 declare const _default: {
     createYamoSchema: typeof createYamoSchema;
     createYamoTable: typeof createYamoTable;

package/lib/yamo/schema.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * YAMO Block Schema Definitions for yamo-memory-mesh
  * Uses Apache Arrow Schema format for LanceDB JavaScript SDK

package/lib/yamo/schema.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * YAMO Block Schema Definitions for yamo-memory-mesh
  * Uses Apache Arrow Schema format for LanceDB JavaScript SDK
@@ -5,41 +6,29 @@
  * Provides schema and table creation for YAMO block persistence.
  * YAMO blocks provide audit trail for all memory operations.
  */
-
 import * as arrow from "apache-arrow";
-import * as lancedb from "@lancedb/lancedb";
-
 /**
  * Create YAMO blocks table schema
  * Defines the structure for storing YAMO protocol blocks
  * @returns {arrow.Schema} Arrow schema for YAMO blocks
  */
-export function createYamoSchema(): arrow.Schema {
-  return new arrow.Schema([
-    // Core identifiers
-    new arrow.Field("id", new arrow.Utf8(), false),
-    new arrow.Field("agent_id", new arrow.Utf8(), true),
-
-    // Operation tracking
-    new arrow.Field("operation_type", new arrow.Utf8(), false), // 'retain', 'recall', 'reflect'
-    new arrow.Field("yamo_text", new arrow.Utf8(), false), // Full YAMO block content
-
-    // Temporal
-    new arrow.Field(
-      "timestamp",
-      new arrow.Timestamp(arrow.TimeUnit.MILLISECOND),
-      false,
-    ),
-
-    // Blockchain fields (optional, nullable) - for future anchoring
-    new arrow.Field("block_hash", new arrow.Utf8(), true), // Hash of this block
-    new arrow.Field("prev_hash", new arrow.Utf8(), true), // Hash of previous block (for chain)
-
-    // Metadata (JSON string for flexibility)
-    new arrow.Field("metadata", new arrow.Utf8(), true), // Additional metadata as JSON
-  ]);
+export function createYamoSchema() {
+    return new arrow.Schema([
+        // Core identifiers
+        new arrow.Field("id", new arrow.Utf8(), false),
+        new arrow.Field("agent_id", new arrow.Utf8(), true),
+        // Operation tracking
+        new arrow.Field("operation_type", new arrow.Utf8(), false), // 'retain', 'recall', 'reflect'
+        new arrow.Field("yamo_text", new arrow.Utf8(), false), // Full YAMO block content
+        // Temporal
+        new arrow.Field("timestamp", new arrow.Timestamp(arrow.TimeUnit.MILLISECOND), false),
+        // Blockchain fields (optional, nullable) - for future anchoring
+        new arrow.Field("block_hash", new arrow.Utf8(), true), // Hash of this block
+        new arrow.Field("prev_hash", new arrow.Utf8(), true), // Hash of previous block (for chain)
+        // Metadata (JSON string for flexibility)
+        new arrow.Field("metadata", new arrow.Utf8(), true), // Additional metadata as JSON
+    ]);
 }
-
 /**
  * Create YAMO blocks table in LanceDB
  * Creates the table if it doesn't exist, opens it if it does
@@ -49,83 +38,67 @@ export function createYamoSchema(): arrow.Schema {
  * @returns {Promise<lancedb.Table>} The created or opened table
  * @throws {Error} If table creation fails
  */
-export async function createYamoTable(
-  db: lancedb.Connection,
-  tableName: string = "yamo_blocks",
-): Promise<lancedb.Table> {
-  try {
-    // Check if table already exists
-    const existingTables = await db.tableNames();
-
-    if (existingTables.includes(tableName)) {
-      // Table exists, open it
-      return await db.openTable(tableName);
+export async function createYamoTable(db, tableName = "yamo_blocks") {
+    try {
+        // Check if table already exists
+        const existingTables = await db.tableNames();
+        if (existingTables.includes(tableName)) {
+            // Table exists, open it
+            return await db.openTable(tableName);
+        }
+        // Create new table with YAMO schema
+        const schema = createYamoSchema();
+        const table = await db.createTable(tableName, [], { schema });
+        return table;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to create YAMO table '${tableName}': ${message}`);
     }
-
-    // Create new table with YAMO schema
-    const schema = createYamoSchema();
-    const table = await db.createTable(tableName, [], { schema } as any);
-
-    return table;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to create YAMO table '${tableName}': ${message}`);
-  }
-}
-
-export interface YamoRecordValidationResult {
-  valid: boolean;
-  errors: string[];
 }
-
 /**
  * Validate a YAMO block record before insertion
  * Checks for required fields and valid values
  */
-export function validateYamoRecord(record: any): YamoRecordValidationResult {
-  const errors: string[] = [];
-
-  // Check required fields
-  if (!record.id) {
-    errors.push("Missing required field: id");
-  }
-
-  if (!record.operation_type) {
-    errors.push("Missing required field: operation_type");
-  } else {
-    // Validate operation_type is one of the allowed values
-    const validTypes = ["retain", "recall", "reflect"];
-    if (!validTypes.includes(record.operation_type)) {
-      errors.push(
-        `Invalid operation_type: ${record.operation_type}. Must be one of: ${validTypes.join(", ")}`,
-      );
+export function validateYamoRecord(record) {
+    const errors = [];
+    // Check required fields
+    if (!record.id) {
+        errors.push("Missing required field: id");
+    }
+    if (!record.operation_type) {
+        errors.push("Missing required field: operation_type");
+    }
+    else {
+        // Validate operation_type is one of the allowed values
+        const validTypes = ["retain", "recall", "reflect"];
+        if (!validTypes.includes(record.operation_type)) {
+            errors.push(`Invalid operation_type: ${record.operation_type}. Must be one of: ${validTypes.join(", ")}`);
+        }
+    }
+    if (!record.yamo_text) {
+        errors.push("Missing required field: yamo_text");
     }
-  }
-
-  if (!record.yamo_text) {
-    errors.push("Missing required field: yamo_text");
-  } else {
-    // Validate YAMO block format
-    const requiredSections = [
-      "agent:",
-      "intent:",
-      "context:",
-      "output:",
-      "log:",
-    ];
-    for (const section of requiredSections) {
-      if (!record.yamo_text.includes(section)) {
-        errors.push(`YAMO block missing required section: ${section}`);
-      }
+    else {
+        // Validate YAMO block format
+        const requiredSections = [
+            "agent:",
+            "intent:",
+            "context:",
+            "output:",
+            "log:",
+        ];
+        for (const section of requiredSections) {
+            if (!record.yamo_text.includes(section)) {
+                errors.push(`YAMO block missing required section: ${section}`);
+            }
+        }
     }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
 }
-
 /**
  * Generate a YAMO block ID
  * Creates a unique ID for a YAMO block
@@ -133,12 +106,11 @@ export function validateYamoRecord(record: any): YamoRecordValidationResult {
  * @param {string} operationType - Type of operation
  * @returns {string} Generated YAMO block ID
  */
-export function generateYamoId(operationType: string): string {
-  const timestamp = Date.now();
-  const random = Math.random().toString(36).substring(2, 10);
-  return `yamo_${operationType}_${timestamp}_${random}`;
+export function generateYamoId(operationType) {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `yamo_${operationType}_${timestamp}_${random}`;
 }
-
 /**
  * Check if a table uses YAMO schema
  * Detects if a table has the YAMO block schema structure
@@ -146,20 +118,16 @@ export function generateYamoId(operationType: string): string {
  * @param {arrow.Schema} schema - Table schema to check
  * @returns {boolean} True if YAMO schema detected
  */
-export function isYamoSchema(schema: arrow.Schema): boolean {
-  // Check for unique YAMO fields
-  const hasYamoFields = schema.fields.some(
-    (f) => f.name === "operation_type" || f.name === "yamo_text",
-  );
-
-  return hasYamoFields;
+export function isYamoSchema(schema) {
+    // Check for unique YAMO fields
+    const hasYamoFields = schema.fields.some((f) => f.name === "operation_type" || f.name === "yamo_text");
+    return hasYamoFields;
 }
-
 // Export schema function as default for consistency with lancedb/schema.js
 export default {
-  createYamoSchema,
-  createYamoTable,
-  validateYamoRecord,
-  generateYamoId,
-  isYamoSchema,
+    createYamoSchema,
+    createYamoTable,
+    validateYamoRecord,
+    generateYamoId,
+    isYamoSchema,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamo/memory-mesh",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Portable semantic memory system with Layer 0 Scrubber for YAMO agents (v3 Singularity Edition)",
   "type": "module",
   "main": "lib/memory/index.js",
@@ -16,7 +16,9 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test test/*.test.js",
+    "test": "npm run build && npx tsx --test test/**/*.test.ts",
+    "test:unit": "npx tsx --test test/unit/*.test.ts",
+    "test:e2e": "npm run build && npx tsx --test test/e2e/*.test.ts",
     "type-check": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },