@yamo/memory-mesh 3.0.0 → 3.0.2

package/lib/memory/adapters/errors.d.ts

@@ -6,64 +6,72 @@
  * error constructor.
  */
 export declare class LanceDBError extends Error {
-    code: string;
-    details: Record<string, any>;
-    timestamp: string;
+    code: any;
+    details: any;
+    timestamp: any;
     /**
      * Create a new LanceDBError
      * @param {string} message - Human-readable error message
      * @param {string} code - Machine-readable error code (e.g., 'EMBEDDING_ERROR')
      * @param {Object} details - Additional error context and metadata
      */
-    constructor(message: string, code: string, details?: Record<string, any>);
+    constructor(message: any, code: any, details?: {});
 }
 /**
  * Error raised when embedding generation or comparison fails
  */
 export declare class EmbeddingError extends LanceDBError {
-    constructor(message: string, details?: Record<string, any>);
+    constructor(message: any, details: any);
 }
 /**
  * Error raised when storage operations (read/write/delete) fail
  */
 export declare class StorageError extends LanceDBError {
-    constructor(message: string, details?: Record<string, any>);
+    constructor(message: any, details: any);
 }
 /**
  * Error raised when database queries fail or return invalid results
  */
 export declare class QueryError extends LanceDBError {
-    constructor(message: string, details?: Record<string, any>);
+    constructor(message: any, details: any);
 }
 /**
  * Error raised when configuration is missing or invalid
  */
 export declare class ConfigurationError extends LanceDBError {
-    constructor(message: string, details?: Record<string, any>);
+    constructor(message: any, details: any);
 }
 /**
  * Sanitize error messages by redacting sensitive information
  * @param {string} message - Error message to sanitize
  * @returns {string} Sanitized error message
  */
-export declare function sanitizeErrorMessage(message: unknown): string;
-export interface ErrorResponse {
-    success: boolean;
-    error: {
-        code: string;
-        message: string;
-        details?: Record<string, any>;
-        context?: Record<string, any>;
-        stack?: string;
-    };
-}
+export declare function sanitizeErrorMessage(message: any): string;
 /**
  * Normalize errors into a consistent response format
  * @param {Error} error - The error to handle
  * @param {Object} context - Additional context about where/when the error occurred
  * @returns {Object} Formatted error response with success: false
  */
-export declare function handleError(error: unknown, context?: Record<string, any>): ErrorResponse;
+export declare function handleError(error: any, context?: {}): {
+    success: boolean;
+    error: {
+        code: any;
+        message: string;
+        details: any;
+        context: {};
+        stack?: undefined;
+    };
+} | {
+    success: boolean;
+    error: {
+        code: string;
+        message: string;
+        stack: string;
+        context: {};
+        details?: undefined;
+    };
+};
 declare const _default: {
     LanceDBError: typeof LanceDBError;
     EmbeddingError: typeof EmbeddingError;

package/lib/memory/adapters/errors.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Custom error classes for LanceDB operations
  *

package/lib/memory/adapters/errors.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * Custom error classes for LanceDB operations
  *
@@ -6,161 +7,123 @@
  * error constructor.
  */
 export class LanceDBError extends Error {
-  code: string;
-  details: Record<string, any>;
-  timestamp: string;
-
-  /**
-   * Create a new LanceDBError
-   * @param {string} message - Human-readable error message
-   * @param {string} code - Machine-readable error code (e.g., 'EMBEDDING_ERROR')
-   * @param {Object} details - Additional error context and metadata
-   */
-  constructor(
-    message: string,
-    code: string,
-    details: Record<string, any> = {},
-  ) {
-    super(message);
-    this.name = "LanceDBError";
-    this.code = code;
-    this.details = details;
-    this.timestamp = new Date().toISOString();
-
-    // Capture stack trace for proper debugging (Node.js best practice)
-    // This ensures stack traces point to where the error was thrown,
-    // not to the error constructor itself
-    Error.captureStackTrace(this, this.constructor);
-  }
+    code;
+    details;
+    timestamp;
+    /**
+     * Create a new LanceDBError
+     * @param {string} message - Human-readable error message
+     * @param {string} code - Machine-readable error code (e.g., 'EMBEDDING_ERROR')
+     * @param {Object} details - Additional error context and metadata
+     */
+    constructor(message, code, details = {}) {
+        super(message);
+        this.name = "LanceDBError";
+        this.code = code;
+        this.details = details;
+        this.timestamp = new Date().toISOString();
+        // Capture stack trace for proper debugging (Node.js best practice)
+        // This ensures stack traces point to where the error was thrown,
+        // not to the error constructor itself
+        Error.captureStackTrace(this, this.constructor);
+    }
 }
-
 /**
  * Error raised when embedding generation or comparison fails
  */
 export class EmbeddingError extends LanceDBError {
-  constructor(message: string, details?: Record<string, any>) {
-    super(message, "EMBEDDING_ERROR", details);
-    this.name = "EmbeddingError";
-  }
+    constructor(message, details) {
+        super(message, "EMBEDDING_ERROR", details);
+        this.name = "EmbeddingError";
+    }
 }
-
 /**
  * Error raised when storage operations (read/write/delete) fail
  */
 export class StorageError extends LanceDBError {
-  constructor(message: string, details?: Record<string, any>) {
-    super(message, "STORAGE_ERROR", details);
-    this.name = "StorageError";
-  }
+    constructor(message, details) {
+        super(message, "STORAGE_ERROR", details);
+        this.name = "StorageError";
+    }
 }
-
 /**
  * Error raised when database queries fail or return invalid results
  */
 export class QueryError extends LanceDBError {
-  constructor(message: string, details?: Record<string, any>) {
-    super(message, "QUERY_ERROR", details);
-    this.name = "QueryError";
-  }
+    constructor(message, details) {
+        super(message, "QUERY_ERROR", details);
+        this.name = "QueryError";
+    }
 }
-
 /**
  * Error raised when configuration is missing or invalid
  */
 export class ConfigurationError extends LanceDBError {
-  constructor(message: string, details?: Record<string, any>) {
-    super(message, "CONFIGURATION_ERROR", details);
-    this.name = "ConfigurationError";
-  }
+    constructor(message, details) {
+        super(message, "CONFIGURATION_ERROR", details);
+        this.name = "ConfigurationError";
+    }
 }
-
 /**
  * Sanitize error messages by redacting sensitive information
  * @param {string} message - Error message to sanitize
  * @returns {string} Sanitized error message
  */
-export function sanitizeErrorMessage(message: unknown): string {
-  if (typeof message !== "string") {
-    return "[Non-string error message]";
-  }
-
-  // Redact common sensitive patterns
-  return (
-    message
-      // Redact Bearer tokens
-      .replace(/Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, "Bearer [REDACTED]")
-      // Redact OpenAI API keys (sk- followed by 32+ chars)
-      .replace(/sk-[A-Za-z0-9]{32,}/g, "sk-[REDACTED]")
-      // Redact generic API keys (20+ alphanumeric chars after api_key)
-      .replace(/api_key["\s:]+[A-Za-z0-9]{20,}/gi, "api_key: [REDACTED]")
-      // Redact environment variable patterns that might contain secrets
-      .replace(
-        /(OPENAI_API_KEY|ANTHROPIC_API_KEY|GOOGLE_API_KEY)["='\s]+[A-Za-z0-9\-_]+/gi,
-        "$1=[REDACTED]",
-      )
-      // Redact Authorization headers
-      .replace(/Authorization:\s*[^"\r\n]+/gi, "Authorization: [REDACTED]")
-      // Redact potential JWT tokens
-      .replace(
-        /eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g,
-        "[JWT_REDACTED]",
-      )
-  );
+export function sanitizeErrorMessage(message) {
+    if (typeof message !== "string") {
+        return "[Non-string error message]";
+    }
+    // Redact common sensitive patterns
+    return (message
+        // Redact Bearer tokens
+        .replace(/Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, "Bearer [REDACTED]")
+        // Redact OpenAI API keys (sk- followed by 32+ chars)
+        .replace(/sk-[A-Za-z0-9]{32,}/g, "sk-[REDACTED]")
+        // Redact generic API keys (20+ alphanumeric chars after api_key)
+        .replace(/api_key["\s:]+[A-Za-z0-9]{20,}/gi, "api_key: [REDACTED]")
+        // Redact environment variable patterns that might contain secrets
+        .replace(/(OPENAI_API_KEY|ANTHROPIC_API_KEY|GOOGLE_API_KEY)["='\s]+[A-Za-z0-9\-_]+/gi, "$1=[REDACTED]")
+        // Redact Authorization headers
+        .replace(/Authorization:\s*[^"\r\n]+/gi, "Authorization: [REDACTED]")
+        // Redact potential JWT tokens
+        .replace(/eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*/g, "[JWT_REDACTED]"));
 }
-
-export interface ErrorResponse {
-  success: boolean;
-  error: {
-    code: string;
-    message: string;
-    details?: Record<string, any>;
-    context?: Record<string, any>;
-    stack?: string;
-  };
-}
-
 /**
  * Normalize errors into a consistent response format
  * @param {Error} error - The error to handle
  * @param {Object} context - Additional context about where/when the error occurred
  * @returns {Object} Formatted error response with success: false
  */
-export function handleError(
-  error: unknown,
-  context: Record<string, any> = {},
-): ErrorResponse {
-  if (error instanceof LanceDBError) {
+export function handleError(error, context = {}) {
+    if (error instanceof LanceDBError) {
+        return {
+            success: false,
+            error: {
+                code: error.code,
+                message: sanitizeErrorMessage(error.message),
+                details: error.details,
+                context,
+            },
+        };
+    }
+    const err = error instanceof Error ? error : new Error(String(error));
+    // Wrap unknown errors
     return {
-      success: false,
-      error: {
-        code: error.code,
-        message: sanitizeErrorMessage(error.message),
-        details: error.details,
-        context,
-      },
+        success: false,
+        error: {
+            code: "UNKNOWN_ERROR",
+            message: sanitizeErrorMessage(err.message),
+            stack: process.env.NODE_ENV === "development" ? err.stack : undefined,
+            context,
+        },
     };
-  }
-
-  const err = error instanceof Error ? error : new Error(String(error));
-
-  // Wrap unknown errors
-  return {
-    success: false,
-    error: {
-      code: "UNKNOWN_ERROR",
-      message: sanitizeErrorMessage(err.message),
-      stack: process.env.NODE_ENV === "development" ? err.stack : undefined,
-      context,
-    },
-  };
 }
-
 export default {
-  LanceDBError,
-  EmbeddingError,
-  StorageError,
-  QueryError,
-  ConfigurationError,
-  handleError,
-  sanitizeErrorMessage,
+    LanceDBError,
+    EmbeddingError,
+    StorageError,
+    QueryError,
+    ConfigurationError,
+    handleError,
+    sanitizeErrorMessage,
 };

package/lib/memory/context-manager.d.ts

@@ -1,21 +1,9 @@
-/**
- * MemoryContextManager - High-level memory management for YAMO
- */
-import { MemoryMesh } from "./memory-mesh.js";
-export interface MemoryContextConfig {
-    mesh?: MemoryMesh;
-    autoInit?: boolean;
-    enableCache?: boolean;
-    recallLimit?: number;
-    minImportance?: number;
-    silent?: boolean;
-}
 export declare class MemoryContextManager {
     #private;
     /**
      * Create a new MemoryContextManager
      */
-    constructor(config?: MemoryContextConfig);
+    constructor(config?: {});
     /**
      * Initialize the memory context manager
      */
@@ -23,18 +11,27 @@ export declare class MemoryContextManager {
     /**
      * Capture an interaction as memory
      */
-    captureInteraction(prompt: string, response: string, context?: any): Promise<any>;
+    captureInteraction(prompt: any, response: any, context?: {}): Promise<any>;
     /**
      * Recall relevant memories for a query
      */
-    recallMemories(query: string, options?: any): Promise<any[]>;
+    recallMemories(query: any, options?: {}): Promise<any>;
     /**
      * Format memories for inclusion in prompt
      */
-    formatMemoriesForPrompt(memories: any[], options?: any): string;
+    formatMemoriesForPrompt(memories: any, options?: {}): string;
     clearCache(): void;
-    getCacheStats(): any;
-    healthCheck(): Promise<any>;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    };
+    healthCheck(): Promise<{
+        status: string;
+        timestamp: string;
+        initialized: boolean;
+        checks: {};
+    }>;
     /**
      * Dispose of resources (cleanup timer and cache)
      * Call this when the MemoryContextManager is no longer needed

package/lib/memory/context-manager.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * MemoryContextManager - High-level memory management for YAMO
  */