@mnemoai/core 1.1.0 → 1.1.1

package/{src/migrate.ts → dist/src/migrate.js}

@@ -1,111 +1,52 @@
-// SPDX-License-Identifier: MIT
-/**
- * Migration Utilities
- * Migrates data from old memory-lancedb plugin to memory-lancedb-pro
- */
-
 import { homedir } from "node:os";
 import { join } from "node:path";
 import fs from "node:fs/promises";
-import type { MemoryStore, MemoryEntry } from "./store.js";
 import { loadLanceDB } from "./store.js";
-
-// ============================================================================
-// Types
-// ============================================================================
-
-interface LegacyMemoryEntry {
-  id: string;
-  text: string;
-  vector: number[];
-  importance: number;
-  category: "preference" | "fact" | "decision" | "entity" | "other";
-  createdAt: number;
-  scope?: string;
-}
-
-interface MigrationResult {
-  success: boolean;
-  migratedCount: number;
-  skippedCount: number;
-  errors: string[];
-  summary: string;
-}
-
-interface MigrationOptions {
-  sourceDbPath?: string;
-  dryRun?: boolean;
-  defaultScope?: string;
-  skipExisting?: boolean;
-}
-
-function normalizeLegacyVector(value: unknown): number[] {
+import { log } from "./logger.js";
+function normalizeLegacyVector(value) {
   if (Array.isArray(value)) {
     return value.map((n) => Number(n));
   }
-
-  if (
-    value &&
-    typeof value === "object" &&
-    Symbol.iterator in (value as Record<PropertyKey, unknown>)
-  ) {
-    return Array.from(value as Iterable<unknown>, (n) => Number(n));
+  if (value && typeof value === "object" && Symbol.iterator in value) {
+    return Array.from(value, (n) => Number(n));
   }
-
   return [];
 }
-
-// ============================================================================
-// Default Paths
-// ============================================================================
-
-function getDefaultLegacyPaths(): string[] {
+function getDefaultLegacyPaths() {
   const home = homedir();
   return [
     join(home, ".openclaw", "memory", "lancedb"),
-    join(home, ".claude", "memory", "lancedb"),
+    join(home, ".claude", "memory", "lancedb")
     // Add more legacy paths as needed
   ];
 }
-
-// ============================================================================
-// Migration Functions
-// ============================================================================
-
-export class MemoryMigrator {
-  constructor(private targetStore: MemoryStore) {}
-
-  async migrate(options: MigrationOptions = {}): Promise<MigrationResult> {
-    const result: MigrationResult = {
+class MemoryMigrator {
+  constructor(targetStore) {
+    this.targetStore = targetStore;
+  }
+  async migrate(options = {}) {
+    const result = {
       success: false,
       migratedCount: 0,
       skippedCount: 0,
       errors: [],
-      summary: "",
+      summary: ""
     };
-
     try {
-      // Find source database
       const sourceDbPath = await this.findSourceDatabase(options.sourceDbPath);
       if (!sourceDbPath) {
         result.errors.push("No legacy database found to migrate from");
         result.summary = "Migration failed: No source database found";
         return result;
       }
-
-      console.log(`Migrating from: ${sourceDbPath}`);
-
-      // Load legacy data
+      log.info(`Migrating from: ${sourceDbPath}`);
       const legacyEntries = await this.loadLegacyData(sourceDbPath);
       if (legacyEntries.length === 0) {
         result.summary = "Migration completed: No data to migrate";
         result.success = true;
         return result;
       }
-
-      console.log(`Found ${legacyEntries.length} entries to migrate`);
-
-      // Migrate entries
+      log.info(`Found ${legacyEntries.length} entries to migrate`);
       if (!options.dryRun) {
         const migrationStats = await this.migrateEntries(legacyEntries, options);
         result.migratedCount = migrationStats.migrated;
@@ -116,20 +57,15 @@ export class MemoryMigrator {
         result.success = true;
         return result;
       }
-
       result.success = result.errors.length === 0;
-      result.summary = `Migration ${result.success ? 'completed' : 'completed with errors'}: ` +
-        `${result.migratedCount} migrated, ${result.skippedCount} skipped`;
-
+      result.summary = `Migration ${result.success ? "completed" : "completed with errors"}: ${result.migratedCount} migrated, ${result.skippedCount} skipped`;
     } catch (error) {
       result.errors.push(`Migration failed: ${error instanceof Error ? error.message : String(error)}`);
       result.summary = "Migration failed due to unexpected error";
     }
-
     return result;
   }
-
-  private async findSourceDatabase(explicitPath?: string): Promise<string | null> {
+  async findSourceDatabase(explicitPath) {
     if (explicitPath) {
       try {
         await fs.access(explicitPath);
@@ -138,79 +74,65 @@ export class MemoryMigrator {
         return null;
       }
     }
-
-    // Check default legacy paths
     for (const path of getDefaultLegacyPaths()) {
       try {
         await fs.access(path);
         const files = await fs.readdir(path);
-        // Check for LanceDB files
-        if (files.some(f => f.endsWith('.lance') || f === 'memories.lance')) {
+        if (files.some((f) => f.endsWith(".lance") || f === "memories.lance")) {
           return path;
         }
       } catch {
         continue;
       }
     }
-
     return null;
   }
-
-  private async loadLegacyData(sourceDbPath: string, limit?: number): Promise<LegacyMemoryEntry[]> {
+  async loadLegacyData(sourceDbPath, limit) {
     const lancedb = await loadLanceDB();
     const db = await lancedb.connect(sourceDbPath);
-
     try {
       const table = await db.openTable("memories");
       let query = table.query();
       if (limit) query = query.limit(limit);
       const entries = await query.toArray();
-
-      return entries.map((row): LegacyMemoryEntry => ({
-        id: row.id as string,
-        text: row.text as string,
+      return entries.map((row) => ({
+        id: row.id,
+        text: row.text,
         vector: normalizeLegacyVector(row.vector),
         importance: Number(row.importance),
-        category: (row.category as LegacyMemoryEntry["category"]) || "other",
+        category: row.category || "other",
         createdAt: Number(row.createdAt),
-        scope: row.scope as string | undefined,
+        scope: row.scope
       }));
     } catch (error) {
-      console.warn(`Failed to load legacy data: ${error}`);
+      log.warn(`Failed to load legacy data: ${error}`);
       return [];
     }
   }
-
-  private async migrateEntries(
-    legacyEntries: LegacyMemoryEntry[],
-    options: MigrationOptions
-  ): Promise<{ migrated: number; skipped: number; errors: string[] }> {
+  async migrateEntries(legacyEntries, options) {
     let migrated = 0;
     let skipped = 0;
-    const errors: string[] = [];
-
+    const errors = [];
     const defaultScope = options.defaultScope || "global";
-
     for (const legacy of legacyEntries) {
       try {
-        // Check if entry already exists (if skipExisting is enabled)
         if (options.skipExisting) {
-          if (legacy.id && (await this.targetStore.hasId(legacy.id))) {
+          if (legacy.id && await this.targetStore.hasId(legacy.id)) {
             skipped++;
             continue;
           }
-
           const existing = await this.targetStore.vectorSearch(
-            legacy.vector, 1, 0.9, [legacy.scope || defaultScope]
+            legacy.vector,
+            1,
+            0.9,
+            [legacy.scope || defaultScope]
           );
           if (existing.length > 0 && existing[0].score > 0.95) {
             skipped++;
             continue;
           }
         }
-
-        // Convert legacy entry to new format while preserving legacy identity.
-        const newEntry: MemoryEntry = {
+        const newEntry = {
           id: legacy.id,
           text: legacy.text,
           vector: legacy.vector,
@@ -221,66 +143,47 @@ export class MemoryMigrator {
           metadata: JSON.stringify({
             migratedFrom: "memory-lancedb",
             originalId: legacy.id,
-            originalCreatedAt: legacy.createdAt,
-          }),
+            originalCreatedAt: legacy.createdAt
+          })
         };
-
         await this.targetStore.importEntry(newEntry);
         migrated++;
-
         if (migrated % 100 === 0) {
-          console.log(`Migrated ${migrated}/${legacyEntries.length} entries...`);
+          log.info(`Migrated ${migrated}/${legacyEntries.length} entries...`);
         }
-
       } catch (error) {
         errors.push(`Failed to migrate entry ${legacy.id}: ${error}`);
         skipped++;
       }
     }
-
     return { migrated, skipped, errors };
   }
-
-  async checkMigrationNeeded(sourceDbPath?: string): Promise<{
-    needed: boolean;
-    sourceFound: boolean;
-    sourceDbPath?: string;
-    entryCount?: number;
-  }> {
+  async checkMigrationNeeded(sourceDbPath) {
     const sourcePath = await this.findSourceDatabase(sourceDbPath);
-
     if (!sourcePath) {
       return {
         needed: false,
-        sourceFound: false,
+        sourceFound: false
       };
     }
-
     try {
       const entries = await this.loadLegacyData(sourcePath, 1);
       return {
         needed: entries.length > 0,
         sourceFound: true,
         sourceDbPath: sourcePath,
-        entryCount: entries.length > 0 ? undefined : 0,
+        entryCount: entries.length > 0 ? void 0 : 0
       };
     } catch (error) {
       return {
         needed: false,
         sourceFound: true,
-        sourceDbPath: sourcePath,
+        sourceDbPath: sourcePath
       };
     }
   }
-
-  async verifyMigration(sourceDbPath?: string): Promise<{
-    valid: boolean;
-    sourceCount: number;
-    targetCount: number;
-    issues: string[];
-  }> {
-    const issues: string[] = [];
-
+  async verifyMigration(sourceDbPath) {
+    const issues = [];
     try {
       const sourcePath = await this.findSourceDatabase(sourceDbPath);
       if (!sourcePath) {
@@ -288,65 +191,48 @@ export class MemoryMigrator {
           valid: false,
           sourceCount: 0,
           targetCount: 0,
-          issues: ["Source database not found"],
+          issues: ["Source database not found"]
         };
       }
-
       const sourceEntries = await this.loadLegacyData(sourcePath);
       const targetStats = await this.targetStore.stats();
-
       const sourceCount = sourceEntries.length;
       const targetCount = targetStats.totalCount;
-
       if (targetCount < sourceCount) {
         issues.push(`Target has fewer entries (${targetCount}) than source (${sourceCount})`);
       }
-
       return {
         valid: issues.length === 0,
         sourceCount,
         targetCount,
-        issues,
+        issues
       };
-
     } catch (error) {
       return {
         valid: false,
         sourceCount: 0,
         targetCount: 0,
-        issues: [`Verification failed: ${error}`],
+        issues: [`Verification failed: ${error}`]
       };
     }
   }
 }
-
-export function createMigrator(targetStore: MemoryStore): MemoryMigrator {
+function createMigrator(targetStore) {
   return new MemoryMigrator(targetStore);
 }
-
-export async function migrateFromLegacy(
-  targetStore: MemoryStore,
-  options: MigrationOptions = {}
-): Promise<MigrationResult> {
+async function migrateFromLegacy(targetStore, options = {}) {
   const migrator = createMigrator(targetStore);
   return migrator.migrate(options);
 }
-
-export async function checkForLegacyData(): Promise<{
-  found: boolean;
-  paths: string[];
-  totalEntries: number;
-}> {
-  const paths: string[] = [];
+async function checkForLegacyData() {
+  const paths = [];
   let totalEntries = 0;
-
   for (const path of getDefaultLegacyPaths()) {
     try {
       const lancedb = await loadLanceDB();
       const db = await lancedb.connect(path);
       const table = await db.openTable("memories");
       const entries = await table.query().select(["id"]).toArray();
-
       if (entries.length > 0) {
         paths.push(path);
         totalEntries += entries.length;
@@ -355,10 +241,16 @@ export async function checkForLegacyData(): Promise<{
       continue;
     }
   }
-
   return {
     found: paths.length > 0,
     paths,
-    totalEntries,
+    totalEntries
   };
 }
+export {
+  MemoryMigrator,
+  checkForLegacyData,
+  createMigrator,
+  migrateFromLegacy
+};
+//# sourceMappingURL=migrate.js.map

package/dist/src/migrate.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/migrate.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: MIT\n/**\n * Migration Utilities\n * Migrates data from old memory-lancedb plugin to memory-lancedb-pro\n */\n\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport fs from \"node:fs/promises\";\nimport type { MemoryStore, MemoryEntry } from \"./store.js\";\nimport { loadLanceDB } from \"./store.js\";\nimport { log } from \"./logger.js\";\n\n// ============================================================================\n// Types\n// ============================================================================\n\ninterface LegacyMemoryEntry {\n  id: string;\n  text: string;\n  vector: number[];\n  importance: number;\n  category: \"preference\" | \"fact\" | \"decision\" | \"entity\" | \"other\";\n  createdAt: number;\n  scope?: string;\n}\n\ninterface MigrationResult {\n  success: boolean;\n  migratedCount: number;\n  skippedCount: number;\n  errors: string[];\n  summary: string;\n}\n\ninterface MigrationOptions {\n  sourceDbPath?: string;\n  dryRun?: boolean;\n  defaultScope?: string;\n  skipExisting?: boolean;\n}\n\nfunction normalizeLegacyVector(value: unknown): number[] {\n  if (Array.isArray(value)) {\n    return value.map((n) => Number(n));\n  }\n\n  if (\n    value &&\n    typeof value === \"object\" &&\n    Symbol.iterator in (value as Record<PropertyKey, unknown>)\n  ) {\n    return Array.from(value as Iterable<unknown>, (n) => Number(n));\n  }\n\n  return [];\n}\n\n// ============================================================================\n// Default Paths\n// ============================================================================\n\nfunction getDefaultLegacyPaths(): string[] {\n  const home = homedir();\n  return [\n    join(home, \".openclaw\", \"memory\", \"lancedb\"),\n    join(home, \".claude\", \"memory\", \"lancedb\"),\n    // Add more legacy paths as needed\n  ];\n}\n\n// ============================================================================\n// Migration Functions\n// ============================================================================\n\nexport class MemoryMigrator {\n  constructor(private targetStore: MemoryStore) {}\n\n  async migrate(options: MigrationOptions = {}): Promise<MigrationResult> {\n    const result: MigrationResult = {\n      success: false,\n      migratedCount: 0,\n      skippedCount: 0,\n      errors: [],\n      summary: \"\",\n    };\n\n    try {\n      // Find source database\n      const sourceDbPath = await this.findSourceDatabase(options.sourceDbPath);\n      if (!sourceDbPath) {\n        result.errors.push(\"No legacy database found to migrate from\");\n        result.summary = \"Migration failed: No source database found\";\n        return result;\n      }\n\n      log.info(`Migrating from: ${sourceDbPath}`);\n\n      // Load legacy data\n      const legacyEntries = await this.loadLegacyData(sourceDbPath);\n      if (legacyEntries.length === 0) {\n        result.summary = \"Migration completed: No data to migrate\";\n        result.success = true;\n        return result;\n      }\n\n      log.info(`Found ${legacyEntries.length} entries to migrate`);\n\n      // Migrate entries\n      if (!options.dryRun) {\n        const migrationStats = await this.migrateEntries(legacyEntries, options);\n        result.migratedCount = migrationStats.migrated;\n        result.skippedCount = migrationStats.skipped;\n        result.errors.push(...migrationStats.errors);\n      } else {\n        result.summary = `Dry run: Would migrate ${legacyEntries.length} entries`;\n        result.success = true;\n        return result;\n      }\n\n      result.success = result.errors.length === 0;\n      result.summary = `Migration ${result.success ? 'completed' : 'completed with errors'}: ` +\n        `${result.migratedCount} migrated, ${result.skippedCount} skipped`;\n\n    } catch (error) {\n      result.errors.push(`Migration failed: ${error instanceof Error ? error.message : String(error)}`);\n      result.summary = \"Migration failed due to unexpected error\";\n    }\n\n    return result;\n  }\n\n  private async findSourceDatabase(explicitPath?: string): Promise<string | null> {\n    if (explicitPath) {\n      try {\n        await fs.access(explicitPath);\n        return explicitPath;\n      } catch {\n        return null;\n      }\n    }\n\n    // Check default legacy paths\n    for (const path of getDefaultLegacyPaths()) {\n      try {\n        await fs.access(path);\n        const files = await fs.readdir(path);\n        // Check for LanceDB files\n        if (files.some(f => f.endsWith('.lance') || f === 'memories.lance')) {\n          return path;\n        }\n      } catch {\n        continue;\n      }\n    }\n\n    return null;\n  }\n\n  private async loadLegacyData(sourceDbPath: string, limit?: number): Promise<LegacyMemoryEntry[]> {\n    const lancedb = await loadLanceDB();\n    const db = await lancedb.connect(sourceDbPath);\n\n    try {\n      const table = await db.openTable(\"memories\");\n      let query = table.query();\n      if (limit) query = query.limit(limit);\n      const entries = await query.toArray();\n\n      return entries.map((row): LegacyMemoryEntry => ({\n        id: row.id as string,\n        text: row.text as string,\n        vector: normalizeLegacyVector(row.vector),\n        importance: Number(row.importance),\n        category: (row.category as LegacyMemoryEntry[\"category\"]) || \"other\",\n        createdAt: Number(row.createdAt),\n        scope: row.scope as string | undefined,\n      }));\n    } catch (error) {\n      log.warn(`Failed to load legacy data: ${error}`);\n      return [];\n    }\n  }\n\n  private async migrateEntries(\n    legacyEntries: LegacyMemoryEntry[],\n    options: MigrationOptions\n  ): Promise<{ migrated: number; skipped: number; errors: string[] }> {\n    let migrated = 0;\n    let skipped = 0;\n    const errors: string[] = [];\n\n    const defaultScope = options.defaultScope || \"global\";\n\n    for (const legacy of legacyEntries) {\n      try {\n        // Check if entry already exists (if skipExisting is enabled)\n        if (options.skipExisting) {\n          if (legacy.id && (await this.targetStore.hasId(legacy.id))) {\n            skipped++;\n            continue;\n          }\n\n          const existing = await this.targetStore.vectorSearch(\n            legacy.vector, 1, 0.9, [legacy.scope || defaultScope]\n          );\n          if (existing.length > 0 && existing[0].score > 0.95) {\n            skipped++;\n            continue;\n          }\n        }\n\n        // Convert legacy entry to new format while preserving legacy identity.\n        const newEntry: MemoryEntry = {\n          id: legacy.id,\n          text: legacy.text,\n          vector: legacy.vector,\n          category: legacy.category,\n          scope: legacy.scope || defaultScope,\n          importance: legacy.importance,\n          timestamp: Number.isFinite(legacy.createdAt) ? legacy.createdAt : Date.now(),\n          metadata: JSON.stringify({\n            migratedFrom: \"memory-lancedb\",\n            originalId: legacy.id,\n            originalCreatedAt: legacy.createdAt,\n          }),\n        };\n\n        await this.targetStore.importEntry(newEntry);\n        migrated++;\n\n        if (migrated % 100 === 0) {\n          log.info(`Migrated ${migrated}/${legacyEntries.length} entries...`);\n        }\n\n      } catch (error) {\n        errors.push(`Failed to migrate entry ${legacy.id}: ${error}`);\n        skipped++;\n      }\n    }\n\n    return { migrated, skipped, errors };\n  }\n\n  async checkMigrationNeeded(sourceDbPath?: string): Promise<{\n    needed: boolean;\n    sourceFound: boolean;\n    sourceDbPath?: string;\n    entryCount?: number;\n  }> {\n    const sourcePath = await this.findSourceDatabase(sourceDbPath);\n\n    if (!sourcePath) {\n      return {\n        needed: false,\n        sourceFound: false,\n      };\n    }\n\n    try {\n      const entries = await this.loadLegacyData(sourcePath, 1);\n      return {\n        needed: entries.length > 0,\n        sourceFound: true,\n        sourceDbPath: sourcePath,\n        entryCount: entries.length > 0 ? undefined : 0,\n      };\n    } catch (error) {\n      return {\n        needed: false,\n        sourceFound: true,\n        sourceDbPath: sourcePath,\n      };\n    }\n  }\n\n  async verifyMigration(sourceDbPath?: string): Promise<{\n    valid: boolean;\n    sourceCount: number;\n    targetCount: number;\n    issues: string[];\n  }> {\n    const issues: string[] = [];\n\n    try {\n      const sourcePath = await this.findSourceDatabase(sourceDbPath);\n      if (!sourcePath) {\n        return {\n          valid: false,\n          sourceCount: 0,\n          targetCount: 0,\n          issues: [\"Source database not found\"],\n        };\n      }\n\n      const sourceEntries = await this.loadLegacyData(sourcePath);\n      const targetStats = await this.targetStore.stats();\n\n      const sourceCount = sourceEntries.length;\n      const targetCount = targetStats.totalCount;\n\n      if (targetCount < sourceCount) {\n        issues.push(`Target has fewer entries (${targetCount}) than source (${sourceCount})`);\n      }\n\n      return {\n        valid: issues.length === 0,\n        sourceCount,\n        targetCount,\n        issues,\n      };\n\n    } catch (error) {\n      return {\n        valid: false,\n        sourceCount: 0,\n        targetCount: 0,\n        issues: [`Verification failed: ${error}`],\n      };\n    }\n  }\n}\n\nexport function createMigrator(targetStore: MemoryStore): MemoryMigrator {\n  return new MemoryMigrator(targetStore);\n}\n\nexport async function migrateFromLegacy(\n  targetStore: MemoryStore,\n  options: MigrationOptions = {}\n): Promise<MigrationResult> {\n  const migrator = createMigrator(targetStore);\n  return migrator.migrate(options);\n}\n\nexport async function checkForLegacyData(): Promise<{\n  found: boolean;\n  paths: string[];\n  totalEntries: number;\n}> {\n  const paths: string[] = [];\n  let totalEntries = 0;\n\n  for (const path of getDefaultLegacyPaths()) {\n    try {\n      const lancedb = await loadLanceDB();\n      const db = await lancedb.connect(path);\n      const table = await db.openTable(\"memories\");\n      const entries = await table.query().select([\"id\"]).toArray();\n\n      if (entries.length > 0) {\n        paths.push(path);\n        totalEntries += entries.length;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  return {\n    found: paths.length > 0,\n    paths,\n    totalEntries,\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/mnemo.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Mnemo Core — simplified entry point
+ * Usage: const mnemo = await createMnemo(config)
+ */
+export interface MnemoConfig {
+    embedding: {
+        provider: "openai-compatible";
+        apiKey: string;
+        baseURL?: string;
+        model?: string;
+        dimensions?: number;
+        taskQuery?: string;
+        taskPassage?: string;
+    };
+    dbPath: string;
+    decay?: {
+        recencyHalfLifeDays?: number;
+        recencyWeight?: number;
+        frequencyWeight?: number;
+        intrinsicWeight?: number;
+    };
+    tier?: {
+        coreAccessThreshold?: number;
+        coreImportanceThreshold?: number;
+        peripheralAgeDays?: number;
+    };
+    llm?: {
+        model?: string;
+        baseURL?: string;
+        apiKey?: string;
+    };
+    retrieval?: {
+        candidatePoolSize?: number;
+        rerank?: "cross-encoder" | "lightweight" | "none";
+        rerankApiKey?: string;
+        rerankModel?: string;
+        rerankEndpoint?: string;
+        rerankProvider?: string;
+    };
+}
+export interface MnemoInstance {
+    store(entry: {
+        text: string;
+        category?: string;
+        importance?: number;
+        scope?: string;
+    }): Promise<{
+        id: string;
+    }>;
+    recall(query: string, options?: {
+        limit?: number;
+        scopeFilter?: string[];
+        category?: string;
+    }): Promise<Array<{
+        text: string;
+        score: number;
+        category: string;
+        importance: number;
+        timestamp: number;
+    }>>;
+    stats(): Promise<{
+        totalEntries: number;
+    }>;
+    close(): Promise<void>;
+}
+export declare function createMnemo(config: MnemoConfig): Promise<MnemoInstance>;
+//# sourceMappingURL=mnemo.d.ts.map

package/dist/src/mnemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemo.d.ts","sourceRoot":"","sources":["../../src/mnemo.ts"],"names":[],"mappings":"AACA;;;GAGG;AASH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE;QACT,QAAQ,EAAE,mBAAmB,CAAC;QAC9B,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE;QACN,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,IAAI,CAAC,EAAE;QACL,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,SAAS,CAAC,EAAE;QACV,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,MAAM,CAAC,EAAE,eAAe,GAAG,aAAa,GAAG,MAAM,CAAC;QAClD,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,KAAK,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE5B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC,CAAC;IAEJ,KAAK,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAE3C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAkE7E"}

package/dist/src/mnemo.js

@@ -0,0 +1,66 @@
+import { MemoryStore } from "./store.js";
+import { createRetriever, DEFAULT_RETRIEVAL_CONFIG } from "./retriever.js";
+import { Embedder } from "./embedder.js";
+import { createDecayEngine, DEFAULT_DECAY_CONFIG } from "./decay-engine.js";
+async function createMnemo(config) {
+  const embedder = new Embedder({
+    apiKey: config.embedding.apiKey,
+    baseURL: config.embedding.baseURL,
+    model: config.embedding.model || "voyage-3-large",
+    dimensions: config.embedding.dimensions || 1024,
+    taskQuery: config.embedding.taskQuery,
+    taskPassage: config.embedding.taskPassage
+  });
+  const store = new MemoryStore({
+    dbPath: config.dbPath,
+    embedder
+  });
+  await store.initialize();
+  const decayEngine = createDecayEngine({
+    ...DEFAULT_DECAY_CONFIG,
+    ...config.decay || {}
+  });
+  const retriever = createRetriever(store, embedder, {
+    ...DEFAULT_RETRIEVAL_CONFIG,
+    ...config.retrieval || {}
+  }, { decayEngine });
+  return {
+    async store(entry) {
+      const vector = await embedder.embed(entry.text);
+      const result = await store.store({
+        text: entry.text,
+        vector,
+        category: entry.category || "fact",
+        importance: entry.importance ?? 0.7,
+        scope: entry.scope || "global"
+      });
+      return { id: result.id };
+    },
+    async recall(query, options = {}) {
+      const results = await retriever.retrieve({
+        query,
+        limit: options.limit ?? 5,
+        scopeFilter: options.scopeFilter,
+        category: options.category,
+        source: "manual"
+      });
+      return results.map((r) => ({
+        text: r.entry.text,
+        score: r.score,
+        category: r.entry.category || "fact",
+        importance: r.entry.importance ?? 0.7,
+        timestamp: r.entry.timestamp ?? Date.now()
+      }));
+    },
+    async stats() {
+      const count = await store.count();
+      return { totalEntries: count };
+    },
+    async close() {
+    }
+  };
+}
+export {
+  createMnemo
+};
+//# sourceMappingURL=mnemo.js.map

package/dist/src/mnemo.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mnemo.ts"],
+  "sourcesContent": ["// SPDX-License-Identifier: MIT\n/**\n * Mnemo Core \u2014 simplified entry point\n * Usage: const mnemo = await createMnemo(config)\n */\n\nimport { MemoryStore } from \"./store.js\";\nimport { createRetriever, DEFAULT_RETRIEVAL_CONFIG } from \"./retriever.js\";\nimport { Embedder } from \"./embedder.js\";\nimport { createDecayEngine, DEFAULT_DECAY_CONFIG } from \"./decay-engine.js\";\nimport { SmartExtractor } from \"./smart-extractor.js\";\nimport { createLlmClient } from \"./llm-client.js\";\n\nexport interface MnemoConfig {\n  embedding: {\n    provider: \"openai-compatible\";\n    apiKey: string;\n    baseURL?: string;\n    model?: string;\n    dimensions?: number;\n    taskQuery?: string;\n    taskPassage?: string;\n  };\n  dbPath: string;\n  decay?: {\n    recencyHalfLifeDays?: number;\n    recencyWeight?: number;\n    frequencyWeight?: number;\n    intrinsicWeight?: number;\n  };\n  tier?: {\n    coreAccessThreshold?: number;\n    coreImportanceThreshold?: number;\n    peripheralAgeDays?: number;\n  };\n  llm?: {\n    model?: string;\n    baseURL?: string;\n    apiKey?: string;\n  };\n  retrieval?: {\n    candidatePoolSize?: number;\n    rerank?: \"cross-encoder\" | \"lightweight\" | \"none\";\n    rerankApiKey?: string;\n    rerankModel?: string;\n    rerankEndpoint?: string;\n    rerankProvider?: string;\n  };\n}\n\nexport interface MnemoInstance {\n  store(entry: {\n    text: string;\n    category?: string;\n    importance?: number;\n    scope?: string;\n  }): Promise<{ id: string }>;\n\n  recall(query: string, options?: {\n    limit?: number;\n    scopeFilter?: string[];\n    category?: string;\n  }): Promise<Array<{\n    text: string;\n    score: number;\n    category: string;\n    importance: number;\n    timestamp: number;\n  }>>;\n\n  stats(): Promise<{ totalEntries: number }>;\n\n  close(): Promise<void>;\n}\n\nexport async function createMnemo(config: MnemoConfig): Promise<MnemoInstance> {\n  const embedder = new Embedder({\n    apiKey: config.embedding.apiKey,\n    baseURL: config.embedding.baseURL,\n    model: config.embedding.model || \"voyage-3-large\",\n    dimensions: config.embedding.dimensions || 1024,\n    taskQuery: config.embedding.taskQuery,\n    taskPassage: config.embedding.taskPassage,\n  });\n\n  const store = new MemoryStore({\n    dbPath: config.dbPath,\n    embedder,\n  });\n\n  await store.initialize();\n\n  const decayEngine = createDecayEngine({\n    ...DEFAULT_DECAY_CONFIG,\n    ...(config.decay || {}),\n  });\n\n  const retriever = createRetriever(store, embedder, {\n    ...DEFAULT_RETRIEVAL_CONFIG,\n    ...(config.retrieval || {}),\n  }, { decayEngine });\n\n  return {\n    async store(entry) {\n      const vector = await embedder.embed(entry.text);\n      const result = await store.store({\n        text: entry.text,\n        vector,\n        category: entry.category || \"fact\",\n        importance: entry.importance ?? 0.7,\n        scope: entry.scope || \"global\",\n      });\n      return { id: result.id };\n    },\n\n    async recall(query, options = {}) {\n      const results = await retriever.retrieve({\n        query,\n        limit: options.limit ?? 5,\n        scopeFilter: options.scopeFilter,\n        category: options.category,\n        source: \"manual\",\n      });\n      return results.map(r => ({\n        text: r.entry.text,\n        score: r.score,\n        category: r.entry.category || \"fact\",\n        importance: r.entry.importance ?? 0.7,\n        timestamp: r.entry.timestamp ?? Date.now(),\n      }));\n    },\n\n    async stats() {\n      const count = await store.count();\n      return { totalEntries: count };\n    },\n\n    async close() {\n      // LanceDB handles cleanup automatically\n    },\n  };\n}\n"],
+  "mappings": "AAMA,SAAS,mBAAmB;AAC5B,SAAS,iBAAiB,gCAAgC;AAC1D,SAAS,gBAAgB;AACzB,SAAS,mBAAmB,4BAA4B;AAkExD,eAAsB,YAAY,QAA6C;AAC7E,QAAM,WAAW,IAAI,SAAS;AAAA,IAC5B,QAAQ,OAAO,UAAU;AAAA,IACzB,SAAS,OAAO,UAAU;AAAA,IAC1B,OAAO,OAAO,UAAU,SAAS;AAAA,IACjC,YAAY,OAAO,UAAU,cAAc;AAAA,IAC3C,WAAW,OAAO,UAAU;AAAA,IAC5B,aAAa,OAAO,UAAU;AAAA,EAChC,CAAC;AAED,QAAM,QAAQ,IAAI,YAAY;AAAA,IAC5B,QAAQ,OAAO;AAAA,IACf;AAAA,EACF,CAAC;AAED,QAAM,MAAM,WAAW;AAEvB,QAAM,cAAc,kBAAkB;AAAA,IACpC,GAAG;AAAA,IACH,GAAI,OAAO,SAAS,CAAC;AAAA,EACvB,CAAC;AAED,QAAM,YAAY,gBAAgB,OAAO,UAAU;AAAA,IACjD,GAAG;AAAA,IACH,GAAI,OAAO,aAAa,CAAC;AAAA,EAC3B,GAAG,EAAE,YAAY,CAAC;AAElB,SAAO;AAAA,IACL,MAAM,MAAM,OAAO;AACjB,YAAM,SAAS,MAAM,SAAS,MAAM,MAAM,IAAI;AAC9C,YAAM,SAAS,MAAM,MAAM,MAAM;AAAA,QAC/B,MAAM,MAAM;AAAA,QACZ;AAAA,QACA,UAAU,MAAM,YAAY;AAAA,QAC5B,YAAY,MAAM,cAAc;AAAA,QAChC,OAAO,MAAM,SAAS;AAAA,MACxB,CAAC;AACD,aAAO,EAAE,IAAI,OAAO,GAAG;AAAA,IACzB;AAAA,IAEA,MAAM,OAAO,OAAO,UAAU,CAAC,GAAG;AAChC,YAAM,UAAU,MAAM,UAAU,SAAS;AAAA,QACvC;AAAA,QACA,OAAO,QAAQ,SAAS;AAAA,QACxB,aAAa,QAAQ;AAAA,QACrB,UAAU,QAAQ;AAAA,QAClB,QAAQ;AAAA,MACV,CAAC;AACD,aAAO,QAAQ,IAAI,QAAM;AAAA,QACvB,MAAM,EAAE,MAAM;AAAA,QACd,OAAO,EAAE;AAAA,QACT,UAAU,EAAE,MAAM,YAAY;AAAA,QAC9B,YAAY,EAAE,MAAM,cAAc;AAAA,QAClC,WAAW,EAAE,MAAM,aAAa,KAAK,IAAI;AAAA,MAC3C,EAAE;AAAA,IACJ;AAAA,IAEA,MAAM,QAAQ;AACZ,YAAM,QAAQ,MAAM,MAAM,MAAM;AAChC,aAAO,EAAE,cAAc,MAAM;AAAA,IAC/B;AAAA,IAEA,MAAM,QAAQ;AAAA,IAEd;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/src/noise-filter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Noise Filter
+ * Filters out low-quality memories (meta-questions, agent denials, session boilerplate)
+ * Inspired by openclaw-plugin-continuity's noise filtering approach.
+ */
+export interface NoiseFilterOptions {
+    /** Filter agent denial responses (default: true) */
+    filterDenials?: boolean;
+    /** Filter meta-questions about memory (default: true) */
+    filterMetaQuestions?: boolean;
+    /** Filter session boilerplate (default: true) */
+    filterBoilerplate?: boolean;
+}
+/**
+ * Check if a memory text is noise that should be filtered out.
+ * Returns true if the text is noise.
+ */
+export declare function isNoise(text: string, options?: NoiseFilterOptions): boolean;
+/**
+ * Filter an array of items, removing noise entries.
+ */
+export declare function filterNoise<T>(items: T[], getText: (item: T) => string, options?: NoiseFilterOptions): T[];
+//# sourceMappingURL=noise-filter.d.ts.map

package/dist/src/noise-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise-filter.d.ts","sourceRoot":"","sources":["../../src/noise-filter.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAgDH,MAAM,WAAW,kBAAkB;IACjC,oDAAoD;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAQD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAY/E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC5B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,CAAC,EAAE,CAGL"}