@skillkit/memory 1.8.0

package/dist/index.js

@@ -0,0 +1,976 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var DEFAULT_TIER_PROMOTION_CONFIG, DEFAULT_EMBEDDING_DIMENSION;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    DEFAULT_TIER_PROMOTION_CONFIG = {
+      accessCountThreshold: 5,
+      reinforcementScoreThreshold: 0.7,
+      ageThresholdDays: 7
+    };
+    DEFAULT_EMBEDDING_DIMENSION = 384;
+  }
+});
+
+// src/database/schema.ts
+async function initializeSchema(db) {
+  const tables = ["memories", "memory_vec", "memory_links"];
+  for (const table of tables) {
+    try {
+      await db.run(`?[id] := *${table}{id} :limit 1`);
+    } catch {
+      switch (table) {
+        case "memories":
+          await db.run(CREATE_MEMORIES_TABLE);
+          break;
+        case "memory_vec":
+          await db.run(CREATE_MEMORY_VEC_TABLE);
+          break;
+        case "memory_links":
+          await db.run(CREATE_MEMORY_LINKS_TABLE);
+          break;
+      }
+    }
+  }
+  try {
+    await db.run(CREATE_HNSW_INDEX);
+  } catch {
+  }
+}
+async function dropSchema(db) {
+  try {
+    await db.run("::hnsw drop memory_vec:embedding_idx");
+  } catch {
+  }
+  const tables = ["memory_links", "memory_vec", "memories"];
+  for (const table of tables) {
+    try {
+      await db.run(`::remove ${table}`);
+    } catch {
+    }
+  }
+}
+var CREATE_MEMORIES_TABLE, CREATE_MEMORY_VEC_TABLE, CREATE_MEMORY_LINKS_TABLE, CREATE_HNSW_INDEX;
+var init_schema = __esm({
+  "src/database/schema.ts"() {
+    "use strict";
+    CREATE_MEMORIES_TABLE = `
+:create memories {
+  id: String
+  =>
+  agent_id: String,
+  category: String,
+  tier: String,
+  content: String,
+  reinforcement_score: Float,
+  created_at: String,
+  updated_at: String,
+  access_count: Int,
+  last_accessed_at: String,
+  tags: [String],
+  metadata: String
+}
+`;
+    CREATE_MEMORY_VEC_TABLE = `
+:create memory_vec {
+  id: String
+  =>
+  embedding: <F32; 384>
+}
+`;
+    CREATE_MEMORY_LINKS_TABLE = `
+:create memory_links {
+  id: String
+  =>
+  source_id: String,
+  target_id: String,
+  relationship_type: String,
+  strength: Float,
+  created_at: String
+}
+`;
+    CREATE_HNSW_INDEX = `
+::hnsw create memory_vec:embedding_idx {
+  dim: 384,
+  m: 16,
+  ef_construction: 100,
+  dtype: F32,
+  fields: [embedding],
+  distance: Cosine,
+  filter: null
+}
+`;
+  }
+});
+
+// src/database/cozo-adapter.ts
+import { CozoDb } from "cozo-node";
+import { mkdir } from "fs/promises";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var CozoAdapter;
+var init_cozo_adapter = __esm({
+  "src/database/cozo-adapter.ts"() {
+    "use strict";
+    init_schema();
+    CozoAdapter = class {
+      db = null;
+      dbPath;
+      initialized = false;
+      constructor(options) {
+        this.dbPath = options.dbPath ?? this.getDefaultDbPath(options.agentId);
+      }
+      getDefaultDbPath(agentId) {
+        return join(homedir(), ".skillkit", "agents", agentId, "memory.db");
+      }
+      async initialize() {
+        if (this.initialized) return;
+        await mkdir(dirname(this.dbPath), { recursive: true });
+        this.db = new CozoDb("rocksdb", this.dbPath);
+        await initializeSchema(this.db);
+        this.initialized = true;
+      }
+      async close() {
+        if (this.db) {
+          this.db.close();
+          this.db = null;
+          this.initialized = false;
+        }
+      }
+      async reset() {
+        if (!this.db) throw new Error("Database not initialized");
+        await dropSchema(this.db);
+        await initializeSchema(this.db);
+      }
+      async run(query, params) {
+        if (!this.db) throw new Error("Database not initialized");
+        const result = await this.db.run(query, params);
+        return {
+          headers: result.headers,
+          rows: result.rows,
+          ok: result.ok
+        };
+      }
+      async insertMemory(id, agentId, category, tier, content, reinforcementScore, createdAt, updatedAt, accessCount, lastAccessedAt, tags, metadata) {
+        const query = `
+      ?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] <- [[
+        $id, $agent_id, $category, $tier, $content, $reinforcement_score, $created_at, $updated_at, $access_count, $last_accessed_at, $tags, $metadata
+      ]]
+      :put memories {
+        id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata
+      }
+    `;
+        await this.run(query, {
+          id,
+          agent_id: agentId,
+          category,
+          tier,
+          content,
+          reinforcement_score: reinforcementScore,
+          created_at: createdAt,
+          updated_at: updatedAt,
+          access_count: accessCount,
+          last_accessed_at: lastAccessedAt,
+          tags,
+          metadata: JSON.stringify(metadata)
+        });
+      }
+      async insertEmbedding(id, embedding) {
+        const query = `
+      ?[id, embedding] <- [[$id, $embedding]]
+      :put memory_vec { id, embedding }
+    `;
+        await this.run(query, { id, embedding });
+      }
+      async getMemory(id) {
+        const query = `
+      ?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] :=
+        *memories[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata],
+        id == $id
+    `;
+        const result = await this.run(query, { id });
+        if (result.rows.length === 0) return null;
+        return this.rowToMemory(result.rows[0]);
+      }
+      async getMemoriesByAgent(agentId, limit = 100) {
+        const query = `
+      ?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] :=
+        *memories[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata],
+        agent_id == $agent_id
+      :limit $limit
+    `;
+        const result = await this.run(query, { agent_id: agentId, limit });
+        return result.rows.map((row) => this.rowToMemory(row));
+      }
+      async updateMemory(id, updates) {
+        const existing = await this.getMemory(id);
+        if (!existing) throw new Error(`Memory ${id} not found`);
+        const query = `
+      ?[id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata] <- [[
+        $id, $agent_id, $category, $tier, $content, $reinforcement_score, $created_at, $updated_at, $access_count, $last_accessed_at, $tags, $metadata
+      ]]
+      :put memories {
+        id, agent_id, category, tier, content, reinforcement_score, created_at, updated_at, access_count, last_accessed_at, tags, metadata
+      }
+    `;
+        await this.run(query, {
+          id,
+          agent_id: existing.agentId,
+          category: updates.category ?? existing.category,
+          tier: updates.tier ?? existing.tier,
+          content: updates.content ?? existing.content,
+          reinforcement_score: updates.reinforcementScore ?? existing.reinforcementScore,
+          created_at: existing.createdAt,
+          updated_at: updates.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          access_count: updates.accessCount ?? existing.accessCount,
+          last_accessed_at: updates.lastAccessedAt ?? existing.lastAccessedAt,
+          tags: updates.tags ?? existing.tags,
+          metadata: JSON.stringify(updates.metadata ?? existing.metadata)
+        });
+      }
+      async deleteMemory(id) {
+        const deleteMemory = `
+      ?[id] <- [[$id]]
+      :rm memories { id }
+    `;
+        const deleteEmbedding = `
+      ?[id] <- [[$id]]
+      :rm memory_vec { id }
+    `;
+        await this.run(deleteMemory, { id });
+        await this.run(deleteEmbedding, { id });
+      }
+      async semanticSearch(embedding, limit = 10, _agentId, _category, _tier) {
+        const params = { embedding, limit };
+        const query = `
+      ?[id, score] := ~memory_vec:embedding_idx{ id, embedding |
+        query: $embedding,
+        k: $limit,
+        ef: 50
+      }, score = cos_dist(embedding, $embedding)
+      :order score
+      :limit $limit
+    `;
+        const result = await this.run(query, params);
+        return result.rows.map((row) => ({
+          id: row[0],
+          score: 1 - row[1]
+        }));
+      }
+      async insertLink(id, sourceId, targetId, relationshipType, strength, createdAt) {
+        const query = `
+      ?[id, source_id, target_id, relationship_type, strength, created_at] <- [[
+        $id, $source_id, $target_id, $relationship_type, $strength, $created_at
+      ]]
+      :put memory_links { id, source_id, target_id, relationship_type, strength, created_at }
+    `;
+        await this.run(query, {
+          id,
+          source_id: sourceId,
+          target_id: targetId,
+          relationship_type: relationshipType,
+          strength,
+          created_at: createdAt
+        });
+      }
+      async getLinks(memoryId) {
+        const query = `
+      ?[id, source_id, target_id, relationship_type, strength, created_at] :=
+        *memory_links[id, source_id, target_id, relationship_type, strength, created_at],
+        or(source_id == $memory_id, target_id == $memory_id)
+    `;
+        const result = await this.run(query, { memory_id: memoryId });
+        return result.rows.map((row) => ({
+          id: row[0],
+          sourceId: row[1],
+          targetId: row[2],
+          relationshipType: row[3],
+          strength: row[4],
+          createdAt: row[5]
+        }));
+      }
+      async getStats(agentId) {
+        let condition = "";
+        const params = {};
+        if (agentId) {
+          condition = ", agent_id == $agent_id";
+          params.agent_id = agentId;
+        }
+        const countQuery = `
+      ?[count(id)] := *memories[id, agent_id, _, _, _, _, _, _, _, _, _, _]${condition}
+    `;
+        const countResult = await this.run(countQuery, params);
+        const total = countResult.rows[0]?.[0] ?? 0;
+        const categoryQuery = `
+      ?[category, count(id)] := *memories[id, agent_id, category, _, _, _, _, _, _, _, _, _]${condition}
+    `;
+        const categoryResult = await this.run(categoryQuery, params);
+        const byCategory = {};
+        for (const row of categoryResult.rows) {
+          byCategory[row[0]] = row[1];
+        }
+        const tierQuery = `
+      ?[tier, count(id)] := *memories[id, agent_id, _, tier, _, _, _, _, _, _, _, _]${condition}
+    `;
+        const tierResult = await this.run(tierQuery, params);
+        const byTier = {};
+        for (const row of tierResult.rows) {
+          byTier[row[0]] = row[1];
+        }
+        return {
+          total,
+          byCategory,
+          byTier
+        };
+      }
+      rowToMemory(row) {
+        return {
+          id: row[0],
+          agentId: row[1],
+          category: row[2],
+          tier: row[3],
+          content: row[4],
+          reinforcementScore: row[5],
+          createdAt: row[6],
+          updatedAt: row[7],
+          accessCount: row[8],
+          lastAccessedAt: row[9],
+          tags: row[10],
+          metadata: JSON.parse(row[11])
+        };
+      }
+      get isInitialized() {
+        return this.initialized;
+      }
+      get path() {
+        return this.dbPath;
+      }
+    };
+  }
+});
+
+// src/embeddings/encoder.ts
+import { pipeline, env } from "@xenova/transformers";
+async function initializeEncoder(options = {}) {
+  if (embeddingPipeline) return;
+  if (initPromise) {
+    await initPromise;
+    return;
+  }
+  initPromise = (async () => {
+    if (options.cacheDir) {
+      env.cacheDir = options.cacheDir;
+    }
+    const modelName = options.model ?? DEFAULT_MODEL;
+    embeddingPipeline = await pipeline("feature-extraction", modelName, {
+      quantized: true
+    });
+  })();
+  try {
+    await initPromise;
+  } catch (error) {
+    initPromise = null;
+    throw error;
+  }
+}
+async function encode(text) {
+  if (!embeddingPipeline) {
+    await initializeEncoder();
+  }
+  if (!embeddingPipeline) {
+    throw new Error("Failed to initialize embedding pipeline");
+  }
+  const output = await embeddingPipeline(text, {
+    pooling: "mean",
+    normalize: true
+  });
+  const embedding = Array.from(output.data);
+  if (embedding.length !== DEFAULT_EMBEDDING_DIMENSION) {
+    throw new Error(
+      `Embedding dimension mismatch: expected ${DEFAULT_EMBEDDING_DIMENSION}, got ${embedding.length}`
+    );
+  }
+  return embedding;
+}
+async function encodeBatch(texts) {
+  if (texts.length === 0) return [];
+  if (!embeddingPipeline) {
+    await initializeEncoder();
+  }
+  if (!embeddingPipeline) {
+    throw new Error("Failed to initialize embedding pipeline");
+  }
+  const embeddings = [];
+  for (const text of texts) {
+    const output = await embeddingPipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    embeddings.push(Array.from(output.data));
+  }
+  return embeddings;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same dimension");
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) return 0;
+  return dotProduct / denominator;
+}
+function euclideanDistance(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same dimension");
+  }
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum);
+}
+function isEncoderReady() {
+  return embeddingPipeline !== null;
+}
+async function disposeEncoder() {
+  if (embeddingPipeline) {
+    try {
+      await embeddingPipeline.dispose();
+    } catch {
+    }
+  }
+  embeddingPipeline = null;
+  initPromise = null;
+}
+var embeddingPipeline, initPromise, DEFAULT_MODEL;
+var init_encoder = __esm({
+  "src/embeddings/encoder.ts"() {
+    "use strict";
+    init_types();
+    env.cacheDir = "./.cache/transformers";
+    embeddingPipeline = null;
+    initPromise = null;
+    DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
+  }
+});
+
+// src/embeddings/search.ts
+async function quickSearch(adapter, query, options = {}) {
+  const search = new SemanticSearch(adapter);
+  return search.search(query, options);
+}
+var SemanticSearch;
+var init_search = __esm({
+  "src/embeddings/search.ts"() {
+    "use strict";
+    init_encoder();
+    SemanticSearch = class {
+      constructor(adapter) {
+        this.adapter = adapter;
+      }
+      async search(query, options = {}) {
+        const {
+          agentId,
+          category,
+          tier,
+          limit = 10,
+          threshold = 0.5,
+          minScore = 0
+        } = options;
+        const queryEmbedding = await encode(query);
+        const results = await this.adapter.semanticSearch(
+          queryEmbedding,
+          limit * 5,
+          agentId,
+          category,
+          tier
+        );
+        const searchResults = [];
+        for (const { id, score } of results) {
+          if (score < Math.max(threshold, minScore)) continue;
+          if (searchResults.length >= limit) break;
+          const memory = await this.adapter.getMemory(id);
+          if (!memory) continue;
+          if (agentId && memory.agentId !== agentId) continue;
+          if (category && memory.category !== category) continue;
+          if (tier && memory.tier !== tier) continue;
+          searchResults.push({
+            memory: this.rowToMemory(memory),
+            score
+          });
+        }
+        return searchResults;
+      }
+      async findSimilar(memoryId, limit = 5, excludeSelf = true) {
+        const memory = await this.adapter.getMemory(memoryId);
+        if (!memory) {
+          throw new Error(`Memory ${memoryId} not found`);
+        }
+        const embedding = await encode(memory.content);
+        const results = await this.adapter.semanticSearch(
+          embedding,
+          limit + (excludeSelf ? 1 : 0),
+          memory.agentId
+        );
+        const searchResults = [];
+        for (const { id, score } of results) {
+          if (excludeSelf && id === memoryId) continue;
+          if (searchResults.length >= limit) break;
+          const similarMemory = await this.adapter.getMemory(id);
+          if (!similarMemory) continue;
+          searchResults.push({
+            memory: this.rowToMemory(similarMemory),
+            score
+          });
+        }
+        return searchResults;
+      }
+      async searchByCategory(query, category, limit = 10) {
+        return this.search(query, { category, limit });
+      }
+      async searchByTier(query, tier, limit = 10) {
+        return this.search(query, { tier, limit });
+      }
+      async hybridSearch(query, keywords, options = {}) {
+        const semanticResults = await this.search(query, {
+          ...options,
+          limit: (options.limit ?? 10) * 2
+        });
+        const scoredResults = semanticResults.map((result) => {
+          let keywordBoost = 0;
+          const contentLower = result.memory.content.toLowerCase();
+          for (const keyword of keywords) {
+            if (contentLower.includes(keyword.toLowerCase())) {
+              keywordBoost += 0.1;
+            }
+          }
+          return {
+            ...result,
+            score: Math.min(1, result.score + keywordBoost)
+          };
+        });
+        scoredResults.sort((a, b) => b.score - a.score);
+        return scoredResults.slice(0, options.limit ?? 10);
+      }
+      rowToMemory(row) {
+        return {
+          id: row.id,
+          agentId: row.agentId,
+          category: row.category,
+          tier: row.tier,
+          content: row.content,
+          embedding: row.embedding || [],
+          reinforcementScore: row.reinforcementScore,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+          accessCount: row.accessCount,
+          lastAccessedAt: row.lastAccessedAt,
+          tags: row.tags,
+          metadata: row.metadata
+        };
+      }
+    };
+  }
+});
+
+// src/stores/memory-store.ts
+var memory_store_exports = {};
+__export(memory_store_exports, {
+  MemoryStore: () => MemoryStore
+});
+import { randomUUID } from "crypto";
+var MemoryStore;
+var init_memory_store = __esm({
+  "src/stores/memory-store.ts"() {
+    "use strict";
+    init_cozo_adapter();
+    init_encoder();
+    init_search();
+    MemoryStore = class {
+      adapter;
+      search;
+      constructor(agentId, dbPath) {
+        this.adapter = new CozoAdapter({ agentId, dbPath });
+        this.search = new SemanticSearch(this.adapter);
+      }
+      async initialize() {
+        await this.adapter.initialize();
+      }
+      async close() {
+        await this.adapter.close();
+      }
+      async create(input) {
+        const id = randomUUID();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const embedding = await encode(input.content);
+        await this.adapter.insertMemory(
+          id,
+          input.agentId,
+          input.category,
+          input.tier ?? "warm",
+          input.content,
+          1,
+          now,
+          now,
+          0,
+          now,
+          input.tags ?? [],
+          input.metadata ?? {}
+        );
+        await this.adapter.insertEmbedding(id, embedding);
+        return {
+          id,
+          agentId: input.agentId,
+          category: input.category,
+          tier: input.tier ?? "warm",
+          content: input.content,
+          embedding,
+          reinforcementScore: 1,
+          createdAt: now,
+          updatedAt: now,
+          accessCount: 0,
+          lastAccessedAt: now,
+          tags: input.tags ?? [],
+          metadata: input.metadata ?? {}
+        };
+      }
+      async get(id) {
+        const row = await this.adapter.getMemory(id);
+        if (!row) return null;
+        await this.adapter.updateMemory(id, {
+          accessCount: row.accessCount + 1,
+          lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          id: row.id,
+          agentId: row.agentId,
+          category: row.category,
+          tier: row.tier,
+          content: row.content,
+          embedding: [],
+          reinforcementScore: row.reinforcementScore,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+          accessCount: row.accessCount + 1,
+          lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          tags: row.tags,
+          metadata: row.metadata
+        };
+      }
+      async update(id, input) {
+        const existing = await this.adapter.getMemory(id);
+        if (!existing) {
+          throw new Error(`Memory ${id} not found`);
+        }
+        const updates = {
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (input.category) updates.category = input.category;
+        if (input.tier) updates.tier = input.tier;
+        if (input.tags) updates.tags = input.tags;
+        if (input.metadata) updates.metadata = input.metadata;
+        if (input.content && input.content !== existing.content) {
+          updates.content = input.content;
+          const embedding = await encode(input.content);
+          await this.adapter.insertEmbedding(id, embedding);
+        }
+        await this.adapter.updateMemory(id, updates);
+        const updated = await this.adapter.getMemory(id);
+        if (!updated) {
+          throw new Error(`Failed to update memory ${id}`);
+        }
+        return {
+          id: updated.id,
+          agentId: updated.agentId,
+          category: updated.category,
+          tier: updated.tier,
+          content: updated.content,
+          embedding: [],
+          reinforcementScore: updated.reinforcementScore,
+          createdAt: updated.createdAt,
+          updatedAt: updated.updatedAt,
+          accessCount: updated.accessCount,
+          lastAccessedAt: updated.lastAccessedAt,
+          tags: updated.tags,
+          metadata: updated.metadata
+        };
+      }
+      async delete(id) {
+        await this.adapter.deleteMemory(id);
+      }
+      async list(agentId, limit = 100) {
+        const rows = await this.adapter.getMemoriesByAgent(agentId, limit);
+        return rows.map((row) => ({
+          id: row.id,
+          agentId: row.agentId,
+          category: row.category,
+          tier: row.tier,
+          content: row.content,
+          embedding: [],
+          reinforcementScore: row.reinforcementScore,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+          accessCount: row.accessCount,
+          lastAccessedAt: row.lastAccessedAt,
+          tags: row.tags,
+          metadata: row.metadata
+        }));
+      }
+      async semanticSearch(query, options = {}) {
+        return this.search.search(query, options);
+      }
+      async findSimilar(memoryId, limit = 5) {
+        return this.search.findSimilar(memoryId, limit);
+      }
+      async reinforce(id, amount = 0.1) {
+        const existing = await this.adapter.getMemory(id);
+        if (!existing) {
+          throw new Error(`Memory ${id} not found`);
+        }
+        const newScore = Math.min(1, existing.reinforcementScore + amount);
+        await this.adapter.updateMemory(id, {
+          reinforcementScore: newScore,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return this.get(id);
+      }
+      async weaken(id, amount = 0.1) {
+        const existing = await this.adapter.getMemory(id);
+        if (!existing) {
+          throw new Error(`Memory ${id} not found`);
+        }
+        const newScore = Math.max(0, existing.reinforcementScore - amount);
+        await this.adapter.updateMemory(id, {
+          reinforcementScore: newScore,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return this.get(id);
+      }
+      async link(sourceId, targetId, relationshipType, strength = 1) {
+        const id = randomUUID();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        await this.adapter.insertLink(id, sourceId, targetId, relationshipType, strength, now);
+        return {
+          id,
+          sourceId,
+          targetId,
+          relationshipType,
+          strength,
+          createdAt: now
+        };
+      }
+      async getLinks(memoryId) {
+        const rows = await this.adapter.getLinks(memoryId);
+        return rows.map((row) => ({
+          id: row.id,
+          sourceId: row.sourceId,
+          targetId: row.targetId,
+          relationshipType: row.relationshipType,
+          strength: row.strength,
+          createdAt: row.createdAt
+        }));
+      }
+      async getStats(agentId) {
+        const stats = await this.adapter.getStats(agentId);
+        const byCategory = {
+          fact: stats.byCategory.fact ?? 0,
+          decision: stats.byCategory.decision ?? 0,
+          preference: stats.byCategory.preference ?? 0,
+          pattern: stats.byCategory.pattern ?? 0,
+          insight: stats.byCategory.insight ?? 0,
+          reasoning: stats.byCategory.reasoning ?? 0
+        };
+        const byTier = {
+          warm: stats.byTier.warm ?? 0,
+          long: stats.byTier.long ?? 0
+        };
+        return {
+          totalMemories: stats.total,
+          byCategory,
+          byTier,
+          avgReinforcementScore: 0,
+          oldestMemory: null,
+          newestMemory: null
+        };
+      }
+      async promoteToLongTerm(id) {
+        return this.update(id, { tier: "long" });
+      }
+      async demoteToWarm(id) {
+        return this.update(id, { tier: "warm" });
+      }
+      get isInitialized() {
+        return this.adapter.isInitialized;
+      }
+      get dbPath() {
+        return this.adapter.path;
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_types();
+
+// src/database/index.ts
+init_cozo_adapter();
+init_schema();
+
+// src/embeddings/index.ts
+init_encoder();
+init_search();
+
+// src/stores/index.ts
+init_memory_store();
+
+// src/tiers/tier-manager.ts
+init_types();
+var TierManager = class {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_TIER_PROMOTION_CONFIG, ...config };
+  }
+  evaluateForPromotion(memory) {
+    const score = this.calculatePromotionScore(memory);
+    const threshold = 0.7;
+    const shouldPromote = memory.tier === "warm" && score >= threshold;
+    const shouldDemote = memory.tier === "long" && score < 0.3;
+    let suggestedTier = memory.tier;
+    let reason = "Memory is appropriately tiered";
+    if (shouldPromote) {
+      suggestedTier = "long";
+      reason = this.getPromotionReason(memory);
+    } else if (shouldDemote) {
+      suggestedTier = "warm";
+      reason = this.getDemotionReason(memory);
+    }
+    return {
+      memoryId: memory.id,
+      currentTier: memory.tier,
+      suggestedTier,
+      reason,
+      score
+    };
+  }
+  calculatePromotionScore(memory) {
+    const accessScore = Math.min(1, memory.accessCount / this.config.accessCountThreshold);
+    const reinforcementScore = memory.reinforcementScore / this.config.reinforcementScoreThreshold;
+    const ageMs = Date.now() - new Date(memory.createdAt).getTime();
+    const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+    const ageScore = Math.min(1, ageDays / this.config.ageThresholdDays);
+    const recencyMs = Date.now() - new Date(memory.lastAccessedAt).getTime();
+    const recencyDays = recencyMs / (1e3 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 1 - recencyDays / 30);
+    const weights = {
+      access: 0.3,
+      reinforcement: 0.35,
+      age: 0.15,
+      recency: 0.2
+    };
+    return accessScore * weights.access + Math.min(1, reinforcementScore) * weights.reinforcement + ageScore * weights.age + recencyScore * weights.recency;
+  }
+  async evaluateAll(store, agentId) {
+    const memories = await store.list(agentId);
+    return memories.map((memory) => this.evaluateForPromotion(memory));
+  }
+  async applyRecommendations(store, evaluations) {
+    const promoted = [];
+    const demoted = [];
+    for (const evaluation of evaluations) {
+      if (evaluation.currentTier === evaluation.suggestedTier) continue;
+      if (evaluation.suggestedTier === "long") {
+        await store.promoteToLongTerm(evaluation.memoryId);
+        promoted.push(evaluation.memoryId);
+      } else {
+        await store.demoteToWarm(evaluation.memoryId);
+        demoted.push(evaluation.memoryId);
+      }
+    }
+    return { promoted, demoted };
+  }
+  async autoPromote(store, agentId) {
+    const evaluations = await this.evaluateAll(store, agentId);
+    return this.applyRecommendations(store, evaluations);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  getPromotionReason(memory) {
+    const reasons = [];
+    if (memory.accessCount >= this.config.accessCountThreshold) {
+      reasons.push(`accessed ${memory.accessCount} times`);
+    }
+    if (memory.reinforcementScore >= this.config.reinforcementScoreThreshold) {
+      reasons.push(`high reinforcement (${memory.reinforcementScore.toFixed(2)})`);
+    }
+    const ageDays = (Date.now() - new Date(memory.createdAt).getTime()) / (1e3 * 60 * 60 * 24);
+    if (ageDays >= this.config.ageThresholdDays) {
+      reasons.push(`${Math.floor(ageDays)} days old`);
+    }
+    return reasons.length > 0 ? `Promote to long-term: ${reasons.join(", ")}` : "Memory qualifies for long-term storage";
+  }
+  getDemotionReason(memory) {
+    const reasons = [];
+    if (memory.reinforcementScore < 0.3) {
+      reasons.push(`low reinforcement (${memory.reinforcementScore.toFixed(2)})`);
+    }
+    const recencyDays = (Date.now() - new Date(memory.lastAccessedAt).getTime()) / (1e3 * 60 * 60 * 24);
+    if (recencyDays > 30) {
+      reasons.push(`not accessed in ${Math.floor(recencyDays)} days`);
+    }
+    return reasons.length > 0 ? `Demote to warm: ${reasons.join(", ")}` : "Memory no longer qualifies for long-term storage";
+  }
+};
+function createTierManager(config) {
+  return new TierManager(config);
+}
+
+// src/index.ts
+async function createMemoryStore(agentId, dbPath) {
+  const { MemoryStore: MemoryStore2 } = await Promise.resolve().then(() => (init_memory_store(), memory_store_exports));
+  const store = new MemoryStore2(agentId, dbPath);
+  await store.initialize();
+  return store;
+}
+export {
+  CozoAdapter,
+  DEFAULT_EMBEDDING_DIMENSION,
+  DEFAULT_TIER_PROMOTION_CONFIG,
+  MemoryStore,
+  SemanticSearch,
+  TierManager,
+  cosineSimilarity,
+  createMemoryStore,
+  createTierManager,
+  disposeEncoder,
+  dropSchema,
+  encode,
+  encodeBatch,
+  euclideanDistance,
+  initializeEncoder,
+  initializeSchema,
+  isEncoderReady,
+  quickSearch
+};
+//# sourceMappingURL=index.js.map