@hasna/mementos 0.1.0

package/dist/server/index.js

@@ -0,0 +1,1144 @@
+#!/usr/bin/env bun
+// @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 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 now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+
+// 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 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 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/server/index.ts
+var DEFAULT_PORT = 19428;
+function parsePort() {
+  const envPort = process.env["PORT"];
+  if (envPort) {
+    const p = parseInt(envPort, 10);
+    if (!Number.isNaN(p))
+      return p;
+  }
+  const portArg = process.argv.find((a) => a === "--port" || a.startsWith("--port="));
+  if (portArg) {
+    if (portArg.includes("=")) {
+      return parseInt(portArg.split("=")[1], 10) || DEFAULT_PORT;
+    }
+    const idx = process.argv.indexOf(portArg);
+    return parseInt(process.argv[idx + 1], 10) || DEFAULT_PORT;
+  }
+  return DEFAULT_PORT;
+}
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400"
+};
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+function errorResponse(message, status, details) {
+  const body = { error: message };
+  if (details !== undefined)
+    body["details"] = details;
+  return json(body, status);
+}
+async function readJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function getSearchParams(url) {
+  const params = {};
+  url.searchParams.forEach((v, k) => {
+    params[k] = v;
+  });
+  return params;
+}
+var routes = [];
+function addRoute(method, path, handler) {
+  const paramNames = [];
+  const patternStr = path.replace(/:(\w+)/g, (_match, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  routes.push({
+    method,
+    pattern: new RegExp(`^${patternStr}$`),
+    paramNames,
+    handler
+  });
+}
+function matchRoute(method, pathname) {
+  for (const route of routes) {
+    if (route.method !== method)
+      continue;
+    const match = pathname.match(route.pattern);
+    if (match) {
+      const params = {};
+      route.paramNames.forEach((name, i) => {
+        params[name] = match[i + 1];
+      });
+      return { handler: route.handler, params };
+    }
+  }
+  return null;
+}
+addRoute("GET", "/api/memories", (_req, url) => {
+  const q = getSearchParams(url);
+  const filter = {};
+  if (q["scope"])
+    filter.scope = q["scope"];
+  if (q["category"])
+    filter.category = q["category"];
+  if (q["tags"])
+    filter.tags = q["tags"].split(",");
+  if (q["min_importance"])
+    filter.min_importance = parseInt(q["min_importance"], 10);
+  if (q["pinned"] !== undefined && q["pinned"] !== "")
+    filter.pinned = q["pinned"] === "true";
+  if (q["agent_id"])
+    filter.agent_id = q["agent_id"];
+  if (q["project_id"])
+    filter.project_id = q["project_id"];
+  if (q["limit"])
+    filter.limit = parseInt(q["limit"], 10);
+  if (q["offset"])
+    filter.offset = parseInt(q["offset"], 10);
+  const memories = listMemories(filter);
+  return json({ memories, count: memories.length });
+});
+addRoute("GET", "/api/memories/stats", (_req) => {
+  const db = getDatabase();
+  const total = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'active'").get().c;
+  const byScope = db.query("SELECT scope, COUNT(*) as c FROM memories WHERE status = 'active' GROUP BY scope").all();
+  const byCategory = db.query("SELECT category, COUNT(*) as c FROM memories WHERE status = 'active' GROUP BY category").all();
+  const byStatus = db.query("SELECT status, COUNT(*) as c FROM memories GROUP BY status").all();
+  const pinnedCount = db.query("SELECT COUNT(*) as c FROM memories WHERE pinned = 1 AND status = 'active'").get().c;
+  const expiredCount = db.query("SELECT COUNT(*) as c FROM memories WHERE status = 'expired' OR (expires_at IS NOT NULL AND expires_at < datetime('now'))").get().c;
+  const stats = {
+    total,
+    by_scope: { global: 0, shared: 0, private: 0 },
+    by_category: { preference: 0, fact: 0, knowledge: 0, history: 0 },
+    by_status: { active: 0, archived: 0, expired: 0 },
+    by_agent: {},
+    pinned_count: pinnedCount,
+    expired_count: expiredCount
+  };
+  for (const row of byScope)
+    stats.by_scope[row.scope] = row.c;
+  for (const row of byCategory)
+    stats.by_category[row.category] = row.c;
+  for (const row of byStatus) {
+    if (row.status in stats.by_status) {
+      stats.by_status[row.status] = row.c;
+    }
+  }
+  const byAgent = db.query("SELECT agent_id, COUNT(*) as c FROM memories WHERE status = 'active' AND agent_id IS NOT NULL GROUP BY agent_id").all();
+  for (const row of byAgent)
+    stats.by_agent[row.agent_id] = row.c;
+  return json(stats);
+});
+addRoute("POST", "/api/memories/search", async (req) => {
+  const body = await readJson(req);
+  if (!body || typeof body["query"] !== "string") {
+    return errorResponse("Missing required field: query", 400);
+  }
+  const filter = {};
+  if (body["scope"])
+    filter.scope = body["scope"];
+  if (body["category"])
+    filter.category = body["category"];
+  if (body["tags"])
+    filter.tags = body["tags"];
+  if (body["limit"])
+    filter.limit = body["limit"];
+  const results = searchMemories(body["query"], filter);
+  return json({ results, count: results.length });
+});
+addRoute("POST", "/api/memories/export", async (req) => {
+  const body = await readJson(req) || {};
+  const filter = {};
+  if (body["scope"])
+    filter.scope = body["scope"];
+  if (body["category"])
+    filter.category = body["category"];
+  if (body["agent_id"])
+    filter.agent_id = body["agent_id"];
+  if (body["project_id"])
+    filter.project_id = body["project_id"];
+  if (body["tags"])
+    filter.tags = body["tags"];
+  filter.limit = body["limit"] || 1e4;
+  const memories = listMemories(filter);
+  return json({ memories, count: memories.length });
+});
+addRoute("POST", "/api/memories/import", async (req) => {
+  const body = await readJson(req);
+  if (!body || !Array.isArray(body["memories"])) {
+    return errorResponse("Missing required field: memories (array)", 400);
+  }
+  const overwrite = body["overwrite"] !== false;
+  const dedupeMode = overwrite ? "merge" : "create";
+  const memoriesArr = body["memories"];
+  let imported = 0;
+  const errors = [];
+  for (const mem of memoriesArr) {
+    try {
+      createMemory({
+        ...mem,
+        source: mem["source"] || "imported"
+      }, dedupeMode);
+      imported++;
+    } catch (e) {
+      errors.push(`Failed to import "${mem["key"]}": ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return json({ imported, errors, total: memoriesArr.length }, 201);
+});
+addRoute("POST", "/api/memories/clean", () => {
+  const cleaned = cleanExpiredMemories();
+  return json({ cleaned });
+});
+addRoute("POST", "/api/memories", async (req) => {
+  const body = await readJson(req);
+  if (!body) {
+    return errorResponse("Invalid JSON body", 400);
+  }
+  if (!body["key"] || !body["value"]) {
+    return errorResponse("Missing required fields: key, value", 400);
+  }
+  try {
+    const memory = createMemory(body);
+    return json(memory, 201);
+  } catch (e) {
+    if (e instanceof DuplicateMemoryError) {
+      return errorResponse(e.message, 409);
+    }
+    throw e;
+  }
+});
+addRoute("GET", "/api/memories/:id", (_req, _url, params) => {
+  const memory = getMemory(params["id"]);
+  if (!memory) {
+    return errorResponse("Memory not found", 404);
+  }
+  touchMemory(memory.id);
+  return json(memory);
+});
+addRoute("PATCH", "/api/memories/:id", async (req, _url, params) => {
+  const body = await readJson(req);
+  if (!body) {
+    return errorResponse("Invalid JSON body", 400);
+  }
+  if (body["version"] === undefined) {
+    return errorResponse("Missing required field: version", 400);
+  }
+  try {
+    const memory = updateMemory(params["id"], body);
+    return json(memory);
+  } catch (e) {
+    if (e instanceof MemoryNotFoundError) {
+      return errorResponse(e.message, 404);
+    }
+    if (e instanceof VersionConflictError) {
+      return errorResponse(e.message, 409, {
+        expected: e.expected,
+        actual: e.actual
+      });
+    }
+    throw e;
+  }
+});
+addRoute("DELETE", "/api/memories/:id", (_req, _url, params) => {
+  const deleted = deleteMemory(params["id"]);
+  if (!deleted) {
+    return errorResponse("Memory not found", 404);
+  }
+  return json({ deleted: true });
+});
+addRoute("GET", "/api/agents", () => {
+  const agents = listAgents();
+  return json({ agents, count: agents.length });
+});
+addRoute("POST", "/api/agents", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"]) {
+    return errorResponse("Missing required field: name", 400);
+  }
+  const agent = registerAgent(body["name"], body["description"], body["role"]);
+  return json(agent, 201);
+});
+addRoute("GET", "/api/agents/:id", (_req, _url, params) => {
+  const agent = getAgent(params["id"]);
+  if (!agent) {
+    return errorResponse("Agent not found", 404);
+  }
+  return json(agent);
+});
+addRoute("GET", "/api/projects", () => {
+  const projects = listProjects();
+  return json({ projects, count: projects.length });
+});
+addRoute("POST", "/api/projects", async (req) => {
+  const body = await readJson(req);
+  if (!body || !body["name"] || !body["path"]) {
+    return errorResponse("Missing required fields: name, path", 400);
+  }
+  const project = registerProject(body["name"], body["path"], body["description"], body["memory_prefix"]);
+  return json(project, 201);
+});
+addRoute("GET", "/api/inject", (_req, url) => {
+  const q = getSearchParams(url);
+  const maxTokens = q["max_tokens"] ? parseInt(q["max_tokens"], 10) : 500;
+  const minImportance = 3;
+  const categories = [
+    "preference",
+    "fact",
+    "knowledge"
+  ];
+  const allMemories = [];
+  const globalMems = listMemories({
+    scope: "global",
+    category: categories,
+    min_importance: minImportance,
+    status: "active",
+    project_id: q["project_id"],
+    limit: 50
+  });
+  allMemories.push(...globalMems);
+  if (q["project_id"]) {
+    const sharedMems = listMemories({
+      scope: "shared",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      project_id: q["project_id"],
+      limit: 50
+    });
+    allMemories.push(...sharedMems);
+  }
+  if (q["agent_id"]) {
+    const privateMems = listMemories({
+      scope: "private",
+      category: categories,
+      min_importance: minImportance,
+      status: "active",
+      agent_id: q["agent_id"],
+      limit: 50
+    });
+    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 (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) {
+    const line = `- [${m.scope}/${m.category}] ${m.key}: ${m.value}`;
+    if (totalChars + line.length > charBudget)
+      break;
+    lines.push(line);
+    totalChars += line.length;
+    touchMemory(m.id);
+  }
+  if (lines.length === 0) {
+    return json({ context: "", memories_count: 0 });
+  }
+  const context = `<agent-memories>
+${lines.join(`
+`)}
+</agent-memories>`;
+  return json({ context, memories_count: lines.length });
+});
+async function findFreePort(start) {
+  for (let port = start;port < start + 100; port++) {
+    try {
+      const server = Bun.serve({ port, fetch: () => new Response("") });
+      server.stop(true);
+      return port;
+    } catch {}
+  }
+  return start;
+}
+function startServer(port) {
+  Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const { pathname } = url;
+      if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS_HEADERS });
+      }
+      if (pathname === "/api/health" || pathname === "/health") {
+        return json({ status: "ok", version: "0.1.0" });
+      }
+      const matched = matchRoute(req.method, pathname);
+      if (!matched) {
+        return errorResponse("Not found", 404);
+      }
+      try {
+        return await matched.handler(req, url, matched.params);
+      } catch (e) {
+        console.error(`[mementos-serve] ${req.method} ${pathname}:`, e);
+        const message = e instanceof Error ? e.message : "Internal server error";
+        return errorResponse(message, 500);
+      }
+    }
+  });
+  console.log(`Mementos server listening on http://localhost:${port}`);
+}
+async function main() {
+  const requestedPort = parsePort();
+  const port = await findFreePort(requestedPort);
+  if (port !== requestedPort) {
+    console.log(`Port ${requestedPort} in use, using ${port}`);
+  }
+  startServer(port);
+}
+main();
+export {
+  startServer
+};