@hasna/mementos 0.1.0

package/dist/index.js

@@ -0,0 +1,1174 @@
+// @bun
+// src/types/index.ts
+class MemoryNotFoundError extends Error {
+  constructor(id) {
+    super(`Memory not found: ${id}`);
+    this.name = "MemoryNotFoundError";
+  }
+}
+
+class DuplicateMemoryError extends Error {
+  constructor(key, scope) {
+    super(`Memory already exists with key "${key}" in scope "${scope}"`);
+    this.name = "DuplicateMemoryError";
+  }
+}
+
+class MemoryExpiredError extends Error {
+  constructor(id) {
+    super(`Memory has expired: ${id}`);
+    this.name = "MemoryExpiredError";
+  }
+}
+
+class InvalidScopeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidScopeError";
+  }
+}
+
+class VersionConflictError extends Error {
+  expected;
+  actual;
+  constructor(id, expected, actual) {
+    super(`Version conflict for memory ${id}: expected ${expected}, got ${actual}`);
+    this.name = "VersionConflictError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+}
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestMementosDb(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, ".mementos", "mementos.db");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, ".git")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function getDbPath() {
+  if (process.env["MEMENTOS_DB_PATH"]) {
+    return process.env["MEMENTOS_DB_PATH"];
+  }
+  const cwd = process.cwd();
+  const nearest = findNearestMementosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["MEMENTOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join(gitRoot, ".mementos", "mementos.db");
+    }
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".mementos", "mementos.db");
+}
+function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    memory_prefix TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    role TEXT DEFAULT 'agent',
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_seen_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS memories (
+    id TEXT PRIMARY KEY,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    category TEXT NOT NULL DEFAULT 'knowledge' CHECK(category IN ('preference', 'fact', 'knowledge', 'history')),
+    scope TEXT NOT NULL DEFAULT 'private' CHECK(scope IN ('global', 'shared', 'private')),
+    summary TEXT,
+    tags TEXT DEFAULT '[]',
+    importance INTEGER NOT NULL DEFAULT 5 CHECK(importance >= 1 AND importance <= 10),
+    source TEXT NOT NULL DEFAULT 'agent' CHECK(source IN ('user', 'agent', 'system', 'auto', 'imported')),
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived', 'expired')),
+    pinned INTEGER NOT NULL DEFAULT 0,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    session_id TEXT,
+    metadata TEXT DEFAULT '{}',
+    access_count INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    expires_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    accessed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS memory_tags (
+    memory_id TEXT NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (memory_id, tag)
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT REFERENCES agents(id) ON DELETE SET NULL,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_unique_key
+    ON memories(key, scope, COALESCE(agent_id, ''), COALESCE(project_id, ''), COALESCE(session_id, ''));
+
+  CREATE INDEX IF NOT EXISTS idx_memories_key ON memories(key);
+  CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+  CREATE INDEX IF NOT EXISTS idx_memories_category ON memories(category);
+  CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+  CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance);
+  CREATE INDEX IF NOT EXISTS idx_memories_agent ON memories(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id);
+  CREATE INDEX IF NOT EXISTS idx_memories_pinned ON memories(pinned);
+  CREATE INDEX IF NOT EXISTS idx_memories_expires ON memories(expires_at);
+  CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_tag ON memory_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_memory_tags_memory ON memory_tags(memory_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `
+];
+var _db = null;
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      try {
+        db.exec(MIGRATIONS[i]);
+      } catch {}
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      try {
+        db.exec(migration);
+      } catch {}
+    }
+  }
+}
+function closeDatabase() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+function resetDatabase() {
+  _db = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function resolvePartialId(db, table, partialId) {
+  if (partialId.length >= 36) {
+    const row = db.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
+    return row?.id ?? null;
+  }
+  const rows = db.query(`SELECT id FROM ${table} WHERE id LIKE ?`).all(`${partialId}%`);
+  if (rows.length === 1) {
+    return rows[0].id;
+  }
+  return null;
+}
+// src/db/memories.ts
+function parseMemoryRow(row) {
+  return {
+    id: row["id"],
+    key: row["key"],
+    value: row["value"],
+    category: row["category"],
+    scope: row["scope"],
+    summary: row["summary"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    importance: row["importance"],
+    source: row["source"],
+    status: row["status"],
+    pinned: !!row["pinned"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    access_count: row["access_count"],
+    version: row["version"],
+    expires_at: row["expires_at"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"],
+    accessed_at: row["accessed_at"] || null
+  };
+}
+function createMemory(input, dedupeMode = "merge", db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  let expiresAt = input.expires_at || null;
+  if (input.ttl_ms && !expiresAt) {
+    expiresAt = new Date(Date.now() + input.ttl_ms).toISOString();
+  }
+  const id = uuid();
+  const tags = input.tags || [];
+  const tagsJson = JSON.stringify(tags);
+  const metadataJson = JSON.stringify(input.metadata || {});
+  if (dedupeMode === "merge") {
+    const existing = d.query(`SELECT id, version FROM memories
+         WHERE key = ? AND scope = ?
+           AND COALESCE(agent_id, '') = ?
+           AND COALESCE(project_id, '') = ?
+           AND COALESCE(session_id, '') = ?`).get(input.key, input.scope || "private", input.agent_id || "", input.project_id || "", input.session_id || "");
+    if (existing) {
+      d.run(`UPDATE memories SET
+           value = ?, category = ?, summary = ?, tags = ?,
+           importance = ?, metadata = ?, expires_at = ?,
+           pinned = COALESCE(pinned, 0),
+           version = version + 1, updated_at = ?
+         WHERE id = ?`, [
+        input.value,
+        input.category || "knowledge",
+        input.summary || null,
+        tagsJson,
+        input.importance ?? 5,
+        metadataJson,
+        expiresAt,
+        timestamp,
+        existing.id
+      ]);
+      d.run("DELETE FROM memory_tags WHERE memory_id = ?", [existing.id]);
+      const insertTag2 = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+      for (const tag of tags) {
+        insertTag2.run(existing.id, tag);
+      }
+      return getMemory(existing.id, d);
+    }
+  }
+  d.run(`INSERT INTO memories (id, key, value, category, scope, summary, tags, importance, source, status, pinned, agent_id, project_id, session_id, metadata, access_count, version, expires_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', 0, ?, ?, ?, ?, 0, 1, ?, ?, ?)`, [
+    id,
+    input.key,
+    input.value,
+    input.category || "knowledge",
+    input.scope || "private",
+    input.summary || null,
+    tagsJson,
+    input.importance ?? 5,
+    input.source || "agent",
+    input.agent_id || null,
+    input.project_id || null,
+    input.session_id || null,
+    metadataJson,
+    expiresAt,
+    timestamp,
+    timestamp
+  ]);
+  const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    insertTag.run(id, tag);
+  }
+  return getMemory(id, d);
+}
+function getMemory(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM memories WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return parseMemoryRow(row);
+}
+function getMemoryByKey(key, scope, agentId, projectId, sessionId, db) {
+  const d = db || getDatabase();
+  let sql = "SELECT * FROM memories WHERE key = ?";
+  const params = [key];
+  if (scope) {
+    sql += " AND scope = ?";
+    params.push(scope);
+  }
+  if (agentId) {
+    sql += " AND agent_id = ?";
+    params.push(agentId);
+  }
+  if (projectId) {
+    sql += " AND project_id = ?";
+    params.push(projectId);
+  }
+  if (sessionId) {
+    sql += " AND session_id = ?";
+    params.push(sessionId);
+  }
+  sql += " AND status = 'active' ORDER BY importance DESC LIMIT 1";
+  const row = d.query(sql).get(...params);
+  if (!row)
+    return null;
+  return parseMemoryRow(row);
+}
+function listMemories(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter) {
+    if (filter.scope) {
+      if (Array.isArray(filter.scope)) {
+        conditions.push(`scope IN (${filter.scope.map(() => "?").join(",")})`);
+        params.push(...filter.scope);
+      } else {
+        conditions.push("scope = ?");
+        params.push(filter.scope);
+      }
+    }
+    if (filter.category) {
+      if (Array.isArray(filter.category)) {
+        conditions.push(`category IN (${filter.category.map(() => "?").join(",")})`);
+        params.push(...filter.category);
+      } else {
+        conditions.push("category = ?");
+        params.push(filter.category);
+      }
+    }
+    if (filter.source) {
+      if (Array.isArray(filter.source)) {
+        conditions.push(`source IN (${filter.source.map(() => "?").join(",")})`);
+        params.push(...filter.source);
+      } else {
+        conditions.push("source = ?");
+        params.push(filter.source);
+      }
+    }
+    if (filter.status) {
+      if (Array.isArray(filter.status)) {
+        conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+    } else {
+      conditions.push("status = 'active'");
+    }
+    if (filter.project_id) {
+      conditions.push("project_id = ?");
+      params.push(filter.project_id);
+    }
+    if (filter.agent_id) {
+      conditions.push("agent_id = ?");
+      params.push(filter.agent_id);
+    }
+    if (filter.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.min_importance) {
+      conditions.push("importance >= ?");
+      params.push(filter.min_importance);
+    }
+    if (filter.pinned !== undefined) {
+      conditions.push("pinned = ?");
+      params.push(filter.pinned ? 1 : 0);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      for (const tag of filter.tags) {
+        conditions.push("id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+        params.push(tag);
+      }
+    }
+    if (filter.search) {
+      conditions.push("(key LIKE ? OR value LIKE ? OR summary LIKE ?)");
+      const term = `%${filter.search}%`;
+      params.push(term, term, term);
+    }
+  } else {
+    conditions.push("status = 'active'");
+  }
+  let sql = "SELECT * FROM memories";
+  if (conditions.length > 0) {
+    sql += ` WHERE ${conditions.join(" AND ")}`;
+  }
+  sql += " ORDER BY importance DESC, created_at DESC";
+  if (filter?.limit) {
+    sql += " LIMIT ?";
+    params.push(filter.limit);
+  }
+  if (filter?.offset) {
+    sql += " OFFSET ?";
+    params.push(filter.offset);
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(parseMemoryRow);
+}
+function updateMemory(id, input, db) {
+  const d = db || getDatabase();
+  const existing = getMemory(id, d);
+  if (!existing)
+    throw new MemoryNotFoundError(id);
+  if (existing.version !== input.version) {
+    throw new VersionConflictError(id, input.version, existing.version);
+  }
+  const sets = ["version = version + 1", "updated_at = ?"];
+  const params = [now()];
+  if (input.value !== undefined) {
+    sets.push("value = ?");
+    params.push(input.value);
+  }
+  if (input.category !== undefined) {
+    sets.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.scope !== undefined) {
+    sets.push("scope = ?");
+    params.push(input.scope);
+  }
+  if (input.summary !== undefined) {
+    sets.push("summary = ?");
+    params.push(input.summary);
+  }
+  if (input.importance !== undefined) {
+    sets.push("importance = ?");
+    params.push(input.importance);
+  }
+  if (input.pinned !== undefined) {
+    sets.push("pinned = ?");
+    params.push(input.pinned ? 1 : 0);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.expires_at !== undefined) {
+    sets.push("expires_at = ?");
+    params.push(input.expires_at);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+    d.run("DELETE FROM memory_tags WHERE memory_id = ?", [id]);
+    const insertTag = d.prepare("INSERT OR IGNORE INTO memory_tags (memory_id, tag) VALUES (?, ?)");
+    for (const tag of input.tags) {
+      insertTag.run(id, tag);
+    }
+  }
+  params.push(id);
+  d.run(`UPDATE memories SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getMemory(id, d);
+}
+function deleteMemory(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM memories WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function bulkDeleteMemories(ids, db) {
+  const d = db || getDatabase();
+  if (ids.length === 0)
+    return 0;
+  const placeholders = ids.map(() => "?").join(",");
+  const result = d.run(`DELETE FROM memories WHERE id IN (${placeholders})`, ids);
+  return result.changes;
+}
+function touchMemory(id, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE memories SET access_count = access_count + 1, accessed_at = ? WHERE id = ?", [now(), id]);
+}
+function cleanExpiredMemories(db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const result = d.run("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at < ?", [timestamp]);
+  return result.changes;
+}
+// src/db/agents.ts
+function parseAgentRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    description: row["description"] || null,
+    role: row["role"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    created_at: row["created_at"],
+    last_seen_at: row["last_seen_at"]
+  };
+}
+function registerAgent(name, description, role, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const existing = d.query("SELECT * FROM agents WHERE name = ?").get(name);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    if (description) {
+      d.run("UPDATE agents SET description = ? WHERE id = ?", [
+        description,
+        existingId
+      ]);
+    }
+    if (role) {
+      d.run("UPDATE agents SET role = ? WHERE id = ?", [
+        role,
+        existingId
+      ]);
+    }
+    return getAgent(existingId, d);
+  }
+  const id = shortUuid();
+  d.run("INSERT INTO agents (id, name, description, role, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?)", [id, name, description || null, role || "agent", timestamp, timestamp]);
+  return getAgent(id, d);
+}
+function getAgent(idOrName, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM agents WHERE id = ?").get(idOrName);
+  if (row)
+    return parseAgentRow(row);
+  row = d.query("SELECT * FROM agents WHERE name = ?").get(idOrName);
+  if (row)
+    return parseAgentRow(row);
+  const rows = d.query("SELECT * FROM agents WHERE id LIKE ?").all(`${idOrName}%`);
+  if (rows.length === 1)
+    return parseAgentRow(rows[0]);
+  return null;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(parseAgentRow);
+}
+// src/db/projects.ts
+function parseProjectRow(row) {
+  return {
+    id: row["id"],
+    name: row["name"],
+    path: row["path"],
+    description: row["description"] || null,
+    memory_prefix: row["memory_prefix"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"]
+  };
+}
+function registerProject(name, path, description, memoryPrefix, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const existing = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  if (existing) {
+    const existingId = existing["id"];
+    d.run("UPDATE projects SET updated_at = ? WHERE id = ?", [
+      timestamp,
+      existingId
+    ]);
+    return parseProjectRow(existing);
+  }
+  const id = uuid();
+  d.run("INSERT INTO projects (id, name, path, description, memory_prefix, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [id, name, path, description || null, memoryPrefix || null, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(idOrPath, db) {
+  const d = db || getDatabase();
+  let row = d.query("SELECT * FROM projects WHERE id = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  row = d.query("SELECT * FROM projects WHERE path = ?").get(idOrPath);
+  if (row)
+    return parseProjectRow(row);
+  return null;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM projects ORDER BY updated_at DESC").all();
+  return rows.map(parseProjectRow);
+}
+// src/lib/search.ts
+function parseMemoryRow2(row) {
+  return {
+    id: row["id"],
+    key: row["key"],
+    value: row["value"],
+    category: row["category"],
+    scope: row["scope"],
+    summary: row["summary"] || null,
+    tags: JSON.parse(row["tags"] || "[]"),
+    importance: row["importance"],
+    source: row["source"],
+    status: row["status"],
+    pinned: !!row["pinned"],
+    agent_id: row["agent_id"] || null,
+    project_id: row["project_id"] || null,
+    session_id: row["session_id"] || null,
+    metadata: JSON.parse(row["metadata"] || "{}"),
+    access_count: row["access_count"],
+    version: row["version"],
+    expires_at: row["expires_at"] || null,
+    created_at: row["created_at"],
+    updated_at: row["updated_at"],
+    accessed_at: row["accessed_at"] || null
+  };
+}
+function determineMatchType(memory, queryLower) {
+  if (memory.key.toLowerCase() === queryLower)
+    return "exact";
+  if (memory.tags.some((t) => t.toLowerCase() === queryLower))
+    return "tag";
+  return "fuzzy";
+}
+function computeScore(memory, queryLower) {
+  let score = 0;
+  const keyLower = memory.key.toLowerCase();
+  if (keyLower === queryLower) {
+    score += 10;
+  } else if (keyLower.includes(queryLower)) {
+    score += 7;
+  }
+  if (memory.tags.some((t) => t.toLowerCase() === queryLower)) {
+    score += 6;
+  }
+  if (memory.summary && memory.summary.toLowerCase().includes(queryLower)) {
+    score += 4;
+  }
+  if (memory.value.toLowerCase().includes(queryLower)) {
+    score += 3;
+  }
+  return score;
+}
+function searchMemories(query, filter, db) {
+  const d = db || getDatabase();
+  const queryLower = query.toLowerCase();
+  const queryParam = `%${query}%`;
+  const conditions = [];
+  const params = [];
+  conditions.push("m.status = 'active'");
+  conditions.push("(m.expires_at IS NULL OR m.expires_at >= datetime('now'))");
+  conditions.push(`(m.key LIKE ? OR m.value LIKE ? OR m.summary LIKE ? OR m.id IN (SELECT memory_id FROM memory_tags WHERE tag LIKE ?))`);
+  params.push(queryParam, queryParam, queryParam, queryParam);
+  if (filter) {
+    if (filter.scope) {
+      if (Array.isArray(filter.scope)) {
+        conditions.push(`m.scope IN (${filter.scope.map(() => "?").join(",")})`);
+        params.push(...filter.scope);
+      } else {
+        conditions.push("m.scope = ?");
+        params.push(filter.scope);
+      }
+    }
+    if (filter.category) {
+      if (Array.isArray(filter.category)) {
+        conditions.push(`m.category IN (${filter.category.map(() => "?").join(",")})`);
+        params.push(...filter.category);
+      } else {
+        conditions.push("m.category = ?");
+        params.push(filter.category);
+      }
+    }
+    if (filter.source) {
+      if (Array.isArray(filter.source)) {
+        conditions.push(`m.source IN (${filter.source.map(() => "?").join(",")})`);
+        params.push(...filter.source);
+      } else {
+        conditions.push("m.source = ?");
+        params.push(filter.source);
+      }
+    }
+    if (filter.status) {
+      conditions.shift();
+      if (Array.isArray(filter.status)) {
+        conditions.push(`m.status IN (${filter.status.map(() => "?").join(",")})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("m.status = ?");
+        params.push(filter.status);
+      }
+    }
+    if (filter.project_id) {
+      conditions.push("m.project_id = ?");
+      params.push(filter.project_id);
+    }
+    if (filter.agent_id) {
+      conditions.push("m.agent_id = ?");
+      params.push(filter.agent_id);
+    }
+    if (filter.session_id) {
+      conditions.push("m.session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.min_importance) {
+      conditions.push("m.importance >= ?");
+      params.push(filter.min_importance);
+    }
+    if (filter.pinned !== undefined) {
+      conditions.push("m.pinned = ?");
+      params.push(filter.pinned ? 1 : 0);
+    }
+    if (filter.tags && filter.tags.length > 0) {
+      for (const tag of filter.tags) {
+        conditions.push("m.id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)");
+        params.push(tag);
+      }
+    }
+  }
+  const sql = `SELECT m.* FROM memories m WHERE ${conditions.join(" AND ")}`;
+  const rows = d.query(sql).all(...params);
+  const scored = [];
+  for (const row of rows) {
+    const memory = parseMemoryRow2(row);
+    const rawScore = computeScore(memory, queryLower);
+    if (rawScore === 0)
+      continue;
+    const weightedScore = rawScore * memory.importance / 10;
+    const matchType = determineMatchType(memory, queryLower);
+    scored.push({
+      memory,
+      score: weightedScore,
+      match_type: matchType
+    });
+  }
+  scored.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    return b.memory.importance - a.memory.importance;
+  });
+  const offset = filter?.offset ?? 0;
+  const limit = filter?.limit ?? scored.length;
+  return scored.slice(offset, offset + limit);
+}
+// src/lib/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var DEFAULT_CONFIG = {
+  default_scope: "private",
+  default_category: "knowledge",
+  default_importance: 5,
+  max_entries: 1000,
+  max_entries_per_scope: {
+    global: 500,
+    shared: 300,
+    private: 200
+  },
+  injection: {
+    max_tokens: 500,
+    min_importance: 5,
+    categories: ["preference", "fact"],
+    refresh_interval: 5
+  },
+  sync_agents: ["claude", "codex", "gemini"],
+  auto_cleanup: {
+    enabled: true,
+    expired_check_interval: 3600
+  }
+};
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+var VALID_SCOPES = ["global", "shared", "private"];
+var VALID_CATEGORIES = [
+  "preference",
+  "fact",
+  "knowledge",
+  "history"
+];
+function isValidScope(value) {
+  return VALID_SCOPES.includes(value);
+}
+function isValidCategory(value) {
+  return VALID_CATEGORIES.includes(value);
+}
+function loadConfig() {
+  const configPath = join2(homedir(), ".mementos", "config.json");
+  let fileConfig = {};
+  if (existsSync2(configPath)) {
+    try {
+      const raw = readFileSync(configPath, "utf-8");
+      fileConfig = JSON.parse(raw);
+    } catch {}
+  }
+  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
+  const envScope = process.env["MEMENTOS_DEFAULT_SCOPE"];
+  if (envScope && isValidScope(envScope)) {
+    merged.default_scope = envScope;
+  }
+  const envCategory = process.env["MEMENTOS_DEFAULT_CATEGORY"];
+  if (envCategory && isValidCategory(envCategory)) {
+    merged.default_category = envCategory;
+  }
+  const envImportance = process.env["MEMENTOS_DEFAULT_IMPORTANCE"];
+  if (envImportance) {
+    const parsed = parseInt(envImportance, 10);
+    if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 10) {
+      merged.default_importance = parsed;
+    }
+  }
+  return merged;
+}
+// src/lib/injector.ts
+class MemoryInjector {
+  config;
+  injectedIds = new Set;
+  constructor(config) {
+    this.config = config || loadConfig();
+  }
+  getInjectionContext(options = {}) {
+    const maxTokens = options.max_tokens || this.config.injection.max_tokens;
+    const minImportance = options.min_importance || this.config.injection.min_importance;
+    const categories = options.categories || this.config.injection.categories;
+    const db = options.db;
+    const allMemories = [];
+    const globalMems = listMemories({
+      scope: "global",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      limit: 100
+    }, db);
+    allMemories.push(...globalMems);
+    if (options.project_id) {
+      const sharedMems = listMemories({
+        scope: "shared",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        project_id: options.project_id,
+        limit: 100
+      }, db);
+      allMemories.push(...sharedMems);
+    }
+    if (options.agent_id) {
+      const privateMems = listMemories({
+        scope: "private",
+        category: categories,
+        min_importance: minImportance,
+        status: "active",
+        agent_id: options.agent_id,
+        limit: 100
+      }, db);
+      allMemories.push(...privateMems);
+    }
+    const seen = new Set;
+    const unique = allMemories.filter((m) => {
+      if (seen.has(m.id))
+        return false;
+      seen.add(m.id);
+      return true;
+    });
+    unique.sort((a, b) => {
+      if (a.pinned !== b.pinned)
+        return a.pinned ? -1 : 1;
+      if (b.importance !== a.importance)
+        return b.importance - a.importance;
+      return new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime();
+    });
+    const charBudget = maxTokens * 4;
+    const lines = [];
+    let totalChars = 0;
+    for (const m of unique) {
+      if (this.injectedIds.has(m.id))
+        continue;
+      const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+      if (totalChars + line.length > charBudget)
+        break;
+      lines.push(line);
+      totalChars += line.length;
+      this.injectedIds.add(m.id);
+      touchMemory(m.id, db);
+    }
+    if (lines.length === 0) {
+      return "";
+    }
+    return `<agent-memories>
+${lines.join(`
+`)}
+</agent-memories>`;
+  }
+  resetDedup() {
+    this.injectedIds.clear();
+  }
+  getInjectedCount() {
+    return this.injectedIds.size;
+  }
+}
+// src/lib/retention.ts
+function enforceQuotas(config, db) {
+  const d = db || getDatabase();
+  let totalEvicted = 0;
+  const scopes = ["global", "shared", "private"];
+  for (const scope of scopes) {
+    const limit = config.max_entries_per_scope[scope];
+    if (!limit || limit <= 0)
+      continue;
+    const countRow = d.query("SELECT COUNT(*) as cnt FROM memories WHERE scope = ? AND status = 'active'").get(scope);
+    const count = countRow.cnt;
+    if (count <= limit)
+      continue;
+    const excess = count - limit;
+    const result = d.run(`DELETE FROM memories WHERE id IN (
+        SELECT id FROM memories
+        WHERE scope = ? AND status = 'active' AND pinned = 0
+        ORDER BY importance ASC, created_at ASC
+        LIMIT ?
+      )`, [scope, excess]);
+    totalEvicted += result.changes;
+  }
+  return totalEvicted;
+}
+function archiveStale(staleDays, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000).toISOString();
+  const result = d.run(`UPDATE memories
+     SET status = 'archived', updated_at = ?
+     WHERE status = 'active'
+       AND pinned = 0
+       AND COALESCE(accessed_at, created_at) < ?`, [timestamp, cutoff]);
+  return result.changes;
+}
+function runCleanup(config, db) {
+  const d = db || getDatabase();
+  const expired = cleanExpiredMemories(d);
+  const evicted = enforceQuotas(config, d);
+  const archived = archiveStale(90, d);
+  return { expired, evicted, archived };
+}
+// src/lib/sync.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+function getAgentSyncDir(agentName) {
+  const dir = join3(homedir2(), ".mementos", "agents", agentName);
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+function setHighWaterMark(agentDir, timestamp) {
+  const markFile = join3(agentDir, ".highwatermark");
+  writeFileSync(markFile, timestamp, "utf-8");
+}
+function resolveConflict(local, remote, resolution) {
+  switch (resolution) {
+    case "prefer-local":
+      return "local";
+    case "prefer-remote":
+      return "remote";
+    case "prefer-newer":
+      return new Date(local.updated_at).getTime() >= new Date(remote.updated_at).getTime() ? "local" : "remote";
+  }
+}
+function pushMemories(agentName, agentId, projectId, db) {
+  const agentDir = getAgentSyncDir(agentName);
+  const memories = listMemories({
+    agent_id: agentId,
+    project_id: projectId,
+    status: "active",
+    limit: 1e4
+  }, db);
+  const outFile = join3(agentDir, "memories.json");
+  writeFileSync(outFile, JSON.stringify(memories, null, 2), "utf-8");
+  if (memories.length > 0) {
+    const latest = memories.reduce((a, b) => new Date(a.updated_at).getTime() > new Date(b.updated_at).getTime() ? a : b);
+    setHighWaterMark(agentDir, latest.updated_at);
+  }
+  return memories.length;
+}
+function pullMemories(agentName, conflictResolution = "prefer-newer", db) {
+  const agentDir = getAgentSyncDir(agentName);
+  const inFile = join3(agentDir, "memories.json");
+  if (!existsSync3(inFile)) {
+    return { pulled: 0, conflicts: 0 };
+  }
+  const raw = readFileSync2(inFile, "utf-8");
+  let remoteMemories;
+  try {
+    remoteMemories = JSON.parse(raw);
+  } catch {
+    return { pulled: 0, conflicts: 0 };
+  }
+  let pulled = 0;
+  let conflicts = 0;
+  for (const remote of remoteMemories) {
+    const localMemories = listMemories({
+      search: remote.key,
+      scope: remote.scope,
+      agent_id: remote.agent_id || undefined,
+      project_id: remote.project_id || undefined,
+      limit: 1
+    }, db);
+    const local = localMemories.find((m) => m.key === remote.key);
+    if (local) {
+      const winner = resolveConflict(local, remote, conflictResolution);
+      if (winner === "remote") {
+        createMemory({
+          key: remote.key,
+          value: remote.value,
+          category: remote.category,
+          scope: remote.scope,
+          summary: remote.summary || undefined,
+          tags: remote.tags,
+          importance: remote.importance,
+          source: remote.source,
+          agent_id: remote.agent_id || undefined,
+          project_id: remote.project_id || undefined,
+          session_id: remote.session_id || undefined,
+          metadata: remote.metadata,
+          expires_at: remote.expires_at || undefined
+        }, "merge", db);
+        pulled++;
+      }
+      conflicts++;
+    } else {
+      createMemory({
+        key: remote.key,
+        value: remote.value,
+        category: remote.category,
+        scope: remote.scope,
+        summary: remote.summary || undefined,
+        tags: remote.tags,
+        importance: remote.importance,
+        source: remote.source,
+        agent_id: remote.agent_id || undefined,
+        project_id: remote.project_id || undefined,
+        session_id: remote.session_id || undefined,
+        metadata: remote.metadata,
+        expires_at: remote.expires_at || undefined
+      }, "create", db);
+      pulled++;
+    }
+  }
+  return { pulled, conflicts };
+}
+function syncMemories(agentName, direction = "both", options = {}) {
+  const result = {
+    pushed: 0,
+    pulled: 0,
+    conflicts: 0,
+    errors: []
+  };
+  try {
+    if (direction === "push" || direction === "both") {
+      result.pushed = pushMemories(agentName, options.agent_id, options.project_id, options.db);
+    }
+    if (direction === "pull" || direction === "both") {
+      const pullResult = pullMemories(agentName, options.conflict_resolution || "prefer-newer", options.db);
+      result.pulled = pullResult.pulled;
+      result.conflicts = pullResult.conflicts;
+    }
+  } catch (e) {
+    result.errors.push(e instanceof Error ? e.message : String(e));
+  }
+  return result;
+}
+var defaultSyncAgents = ["claude", "codex", "gemini"];
+export {
+  uuid,
+  updateMemory,
+  touchMemory,
+  syncMemories,
+  shortUuid,
+  searchMemories,
+  runCleanup,
+  resolvePartialId,
+  resetDatabase,
+  registerProject,
+  registerAgent,
+  now,
+  loadConfig,
+  listProjects,
+  listMemories,
+  listAgents,
+  getProject,
+  getMemoryByKey,
+  getMemory,
+  getDbPath,
+  getDatabase,
+  getAgent,
+  enforceQuotas,
+  deleteMemory,
+  defaultSyncAgents,
+  createMemory,
+  closeDatabase,
+  cleanExpiredMemories,
+  bulkDeleteMemories,
+  archiveStale,
+  VersionConflictError,
+  MemoryNotFoundError,
+  MemoryInjector,
+  MemoryExpiredError,
+  InvalidScopeError,
+  DuplicateMemoryError,
+  DEFAULT_CONFIG
+};