@bip-krishna/agentmind 0.1.0

package/packages/storage/src/postgres-store.ts

@@ -0,0 +1,299 @@
+import type { MemoryStore } from "../../core/src/memory-store.js";
+import type { Memory, Project, Source, SearchQuery, SearchResult, RetrievalEvent } from "../../core/src/types.js";
+import { MIGRATIONS } from "./migrations.js";
+
+/**
+ * Postgres + pgvector adapter — same MemoryStore contract as SqliteMemoryStore.
+ * Requires: CREATE EXTENSION vector;
+ * Embeddings stored dual: JSON text `vector` + native `vec` column for pgvector search.
+ */
+
+type PgPool = {
+  query: (text: string, params?: any[]) => Promise<{ rows: any[] }>;
+  end: () => Promise<void>;
+};
+
+export interface PostgresStoreOptions {
+  connectionString: string;
+  maxPool?: number;
+  vectorDimensions?: number; // default 1536
+}
+
+export class PostgresMemoryStore implements MemoryStore {
+  private pool: PgPool;
+  private dimensions: number;
+  private ready: Promise<void>;
+
+  constructor(opts: string | PostgresStoreOptions) {
+    const connectionString = typeof opts === "string" ? opts : opts.connectionString;
+    this.dimensions = typeof opts === "object" ? (opts.vectorDimensions ?? 1536) : 1536;
+    // dynamic import to avoid hard dep if not used
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { Pool } = require("pg");
+    this.pool = new Pool({ connectionString, max: typeof opts === "object" ? (opts.maxPool ?? 10) : 10 });
+    this.ready = this.migrate();
+  }
+
+  private async migrate() {
+    // schema_migrations + core tables
+    for (const m of MIGRATIONS) {
+      if (m.version === 2) {
+        // pgvector extension + vec column
+        try {
+          await this.pool.query(`CREATE EXTENSION IF NOT EXISTS vector`);
+          await this.pool.query(`ALTER TABLE embeddings ADD COLUMN IF NOT EXISTS vec vector(${this.dimensions})`);
+          await this.pool.query(`CREATE INDEX IF NOT EXISTS idx_embeddings_vec ON embeddings USING hnsw (vec vector_cosine_ops)`);
+        } catch {
+          // ignore if extension not available
+        }
+        continue;
+      }
+      // For version 1, run each statement separately for pg
+      const stmts = m.up.split(";").map((s) => s.trim()).filter(Boolean);
+      for (const stmt of stmts) {
+        try { await this.pool.query(stmt); } catch {}
+      }
+    }
+    // Ensure tables exist with pg-compatible types (TEXT -> VARCHAR etc handled)
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE NOT NULL,
+        description TEXT,
+        created_at TIMESTAMPTZ NOT NULL,
+        updated_at TIMESTAMPTZ NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS sources (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        content TEXT,
+        created_at TIMESTAMPTZ NOT NULL,
+        metadata JSONB NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        importance REAL NOT NULL,
+        confidence REAL NOT NULL,
+        status TEXT NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL,
+        updated_at TIMESTAMPTZ NOT NULL,
+        last_accessed_at TIMESTAMPTZ,
+        access_count INTEGER NOT NULL,
+        source_id TEXT REFERENCES sources(id) ON DELETE SET NULL,
+        metadata JSONB NOT NULL,
+        archived INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS embeddings (
+        memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+        vector TEXT NOT NULL,
+        model TEXT NOT NULL,
+        dimensions INTEGER NOT NULL,
+        vec vector(${this.dimensions})
+      );
+      CREATE TABLE IF NOT EXISTS retrieval_events (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        query TEXT NOT NULL,
+        retrieved_memory_ids JSONB NOT NULL,
+        scores JSONB NOT NULL,
+        final_context_tokens INTEGER NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS consolidations (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        summary_memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL,
+        source_memory_ids JSONB NOT NULL,
+        created_at TIMESTAMPTZ NOT NULL
+      );
+    `);
+  }
+
+  private async ensureReady() { await this.ready; }
+
+  // ---- Projects ----
+  async createProject(project: Project): Promise<Project> {
+    await this.ensureReady();
+    await this.pool.query(`INSERT INTO projects (id, name, description, created_at, updated_at) VALUES ($1,$2,$3,$4,$5)`, [project.id, project.name, project.description ?? null, project.createdAt, project.updatedAt]);
+    return project;
+  }
+  async getProject(id: string): Promise<Project | null> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM projects WHERE id=$1`, [id]);
+    if (!rows[0]) return null;
+    return this.mapProject(rows[0]);
+  }
+  async getProjectByName(name: string): Promise<Project | null> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM projects WHERE name=$1`, [name]);
+    if (!rows[0]) return null;
+    return this.mapProject(rows[0]);
+  }
+  async listProjects(): Promise<Project[]> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM projects`);
+    return rows.map(this.mapProject);
+  }
+  async deleteProject(projectId: string): Promise<void> {
+    await this.ensureReady();
+    await this.pool.query(`DELETE FROM projects WHERE id=$1`, [projectId]);
+  }
+
+  // ---- Sources ----
+  async createSource(source: Source): Promise<Source> {
+    await this.ensureReady();
+    await this.pool.query(`INSERT INTO sources (id, project_id, type, content, created_at, metadata) VALUES ($1,$2,$3,$4,$5,$6)`, [source.id, source.projectId, source.type, source.content ?? null, source.createdAt, JSON.stringify(source.metadata)]);
+    return source;
+  }
+  async getSource(id: string): Promise<Source | null> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM sources WHERE id=$1`, [id]);
+    if (!rows[0]) return null;
+    const r = rows[0];
+    return { id: r.id, projectId: r.project_id, type: r.type, content: r.content ?? undefined, createdAt: new Date(r.created_at), metadata: typeof r.metadata === "string" ? JSON.parse(r.metadata) : r.metadata };
+  }
+
+  // ---- Memories ----
+  async createMemory(memory: Memory): Promise<void> {
+    await this.ensureReady();
+    await this.pool.query(`INSERT INTO memories (id, project_id, type, content, importance, confidence, status, created_at, updated_at, last_accessed_at, access_count, source_id, metadata, archived) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14)`, [memory.id, memory.projectId, memory.type, memory.content, memory.importance, memory.confidence ?? 1, memory.status ?? "active", memory.createdAt, memory.updatedAt, memory.lastAccessedAt ?? null, memory.accessCount, memory.sourceId ?? null, JSON.stringify(memory.metadata), memory.archived ? 1 : 0]);
+  }
+  async getMemory(id: string): Promise<Memory | null> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM memories WHERE id=$1`, [id]);
+    if (!rows[0]) return null;
+    return this.mapMemory(rows[0]);
+  }
+  async updateMemory(id: string, update: Partial<Memory>): Promise<void> {
+    await this.ensureReady();
+    const existing = await this.getMemory(id);
+    if (!existing) return;
+    const merged: Memory = { ...existing, ...update, id, updatedAt: update.updatedAt ?? new Date() } as Memory;
+    await this.pool.query(`UPDATE memories SET type=$1, content=$2, importance=$3, confidence=$4, status=$5, created_at=$6, updated_at=$7, last_accessed_at=$8, access_count=$9, source_id=$10, metadata=$11, archived=$12 WHERE id=$13`, [merged.type, merged.content, merged.importance, merged.confidence, merged.status ?? "active", merged.createdAt, merged.updatedAt, merged.lastAccessedAt ?? null, merged.accessCount, merged.sourceId ?? null, JSON.stringify(merged.metadata), merged.archived ? 1 : 0, id]);
+  }
+  async deleteMemory(id: string): Promise<void> {
+    await this.ensureReady();
+    // Deleting embedding automatically via cascade, but also ensure vector cleanup
+    await this.pool.query(`DELETE FROM memories WHERE id=$1`, [id]);
+  }
+  async archiveMemory(id: string): Promise<void> {
+    await this.ensureReady();
+    await this.pool.query(`UPDATE memories SET archived=1, status='archived', updated_at=$1 WHERE id=$2`, [new Date(), id]);
+  }
+  async listMemories(projectId: string): Promise<Memory[]> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM memories WHERE project_id=$1 ORDER BY updated_at DESC`, [projectId]);
+    return rows.map(this.mapMemory);
+  }
+  async search(query: SearchQuery): Promise<SearchResult[]> {
+    await this.ensureReady();
+    // Enforce project isolation first
+    let sql = `SELECT * FROM memories WHERE project_id=$1`;
+    const params: any[] = [query.projectId];
+    let idx = 2;
+    if (query.types?.length) {
+      sql += ` AND type IN (${query.types.map(() => `$${idx++}`).join(",")})`;
+      params.push(...query.types);
+    }
+    if (query.minImportance !== undefined) {
+      sql += ` AND importance >= $${idx++}`;
+      params.push(query.minImportance);
+    }
+    if (!query.includeArchived) sql += ` AND archived=0 AND status != 'archived'`;
+    const { rows } = await this.pool.query(sql, params);
+    const memories = rows.map(this.mapMemory);
+    // Keyword fallback scoring (vector search is done at MemoryEngine level with pgvector via separate query if needed)
+    const qLower = query.query.toLowerCase();
+    const qTokens = new Set(qLower.split(/\W+/).filter(Boolean));
+    const scored = memories.map((m) => {
+      const cLower = m.content.toLowerCase();
+      const cTokens = cLower.split(/\W+/).filter(Boolean);
+      let hits = 0;
+      for (const t of cTokens) if (qTokens.has(t)) hits++;
+      const phraseBoost = cLower.includes(qLower) ? 0.5 : 0;
+      const keywordScore = qTokens.size ? Math.min(1, hits / qTokens.size + phraseBoost) : 0;
+      const recency = Math.exp(-(Date.now() - m.updatedAt.getTime()) / (1000 * 60 * 60 * 24 * 30));
+      const final = keywordScore * 0.7 + m.importance * 0.15 + recency * 0.15;
+      return { memory: m, score: final, semanticScore: 0, keywordScore };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, query.limit ?? 5);
+  }
+
+  // ---- Embeddings ----
+  async upsertEmbedding(memoryId: string, vector: number[], model: string): Promise<void> {
+    await this.ensureReady();
+    const vecStr = `[${vector.join(",")}]`;
+    await this.pool.query(`INSERT INTO embeddings (memory_id, vector, model, dimensions, vec) VALUES ($1,$2,$3,$4,$5::vector) ON CONFLICT (memory_id) DO UPDATE SET vector=EXCLUDED.vector, model=EXCLUDED.model, dimensions=EXCLUDED.dimensions, vec=EXCLUDED.vec`, [memoryId, JSON.stringify(vector), model, vector.length, vecStr]);
+  }
+  async getEmbedding(memoryId: string): Promise<{ vector: number[]; model: string } | null> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT vector, model FROM embeddings WHERE memory_id=$1`, [memoryId]);
+    if (!rows[0]) return null;
+    return { vector: JSON.parse(rows[0].vector), model: rows[0].model };
+  }
+
+  /** pgvector semantic search — use when MemoryEngine wants native vector ranking */
+  async vectorSearch(projectId: string, queryVector: number[], limit = 10): Promise<Array<{ memory: Memory; distance: number }>> {
+    await this.ensureReady();
+    const vecStr = `[${queryVector.join(",")}]`;
+    const { rows } = await this.pool.query(`
+      SELECT m.*, e.vec <=> $1::vector as distance
+      FROM memories m
+      JOIN embeddings e ON e.memory_id = m.id
+      WHERE m.project_id = $2 AND m.archived=0 AND m.status != 'archived'
+      ORDER BY distance ASC
+      LIMIT $3
+    `, [vecStr, projectId, limit]);
+    return rows.map((r) => ({ memory: this.mapMemory(r), distance: Number(r.distance) }));
+  }
+
+  // ---- Retrieval logs ----
+  async logRetrieval(event: RetrievalEvent): Promise<void> {
+    await this.ensureReady();
+    await this.pool.query(`INSERT INTO retrieval_events (id, project_id, query, retrieved_memory_ids, scores, final_context_tokens, created_at) VALUES ($1,$2,$3,$4,$5,$6,$7)`, [event.id, event.projectId, event.query, JSON.stringify(event.retrievedMemoryIds), JSON.stringify(event.scores), event.finalContextTokens, event.createdAt]);
+  }
+  async listRetrievals(projectId: string, limit = 20): Promise<RetrievalEvent[]> {
+    await this.ensureReady();
+    const { rows } = await this.pool.query(`SELECT * FROM retrieval_events WHERE project_id=$1 ORDER BY created_at DESC LIMIT $2`, [projectId, limit]);
+    return rows.map((r) => ({
+      id: r.id,
+      projectId: r.project_id,
+      query: r.query,
+      retrievedMemoryIds: typeof r.retrieved_memory_ids === "string" ? JSON.parse(r.retrieved_memory_ids) : r.retrieved_memory_ids,
+      scores: typeof r.scores === "string" ? JSON.parse(r.scores) : r.scores,
+      finalContextTokens: r.final_context_tokens,
+      createdAt: new Date(r.created_at),
+    }));
+  }
+
+  async close(): Promise<void> { await this.pool.end(); }
+
+  private mapProject = (row: any): Project => ({
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  });
+  private mapMemory = (row: any): Memory => ({
+    id: row.id,
+    projectId: row.project_id,
+    type: row.type,
+    content: row.content,
+    importance: Number(row.importance),
+    confidence: Number(row.confidence),
+    status: row.status,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    lastAccessedAt: row.last_accessed_at ? new Date(row.last_accessed_at) : undefined,
+    accessCount: Number(row.access_count),
+    sourceId: row.source_id ?? undefined,
+    metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+    archived: !!row.archived,
+  });
+}

package/packages/storage/src/sqlite-store.ts

@@ -0,0 +1,298 @@
+import { DatabaseSync } from "node:sqlite";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { MemoryStore } from "../../core/src/memory-store.js";
+import type { Memory, Project, Source, SearchQuery, SearchResult, RetrievalEvent } from "../../core/src/types.js";
+
+export interface SqliteStoreOptions {
+  path?: string; // file path or ":memory:"
+}
+
+export class SqliteMemoryStore implements MemoryStore {
+  private db: DatabaseSync;
+
+  constructor(opts: SqliteStoreOptions = {}) {
+    const dbPath = opts.path ?? ":memory:";
+    if (dbPath !== ":memory:") {
+      const dir = path.dirname(dbPath);
+      if (dir && dir !== "." && dir !== "") fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new DatabaseSync(dbPath);
+    this.migrate();
+  }
+
+  private migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE NOT NULL,
+        description TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS sources (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        content TEXT,
+        created_at TEXT NOT NULL,
+        metadata TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        importance REAL NOT NULL,
+        confidence REAL NOT NULL,
+        status TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        last_accessed_at TEXT,
+        access_count INTEGER NOT NULL,
+        source_id TEXT REFERENCES sources(id) ON DELETE SET NULL,
+        metadata TEXT NOT NULL,
+        archived INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS embeddings (
+        memory_id TEXT PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE,
+        vector TEXT NOT NULL,
+        model TEXT NOT NULL,
+        dimensions INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS retrieval_events (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        query TEXT NOT NULL,
+        retrieved_memory_ids TEXT NOT NULL,
+        scores TEXT NOT NULL,
+        final_context_tokens INTEGER NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memories_project ON memories(project_id);
+      CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+      CREATE TABLE IF NOT EXISTS consolidations (
+        id TEXT PRIMARY KEY,
+        project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        summary_memory_id TEXT REFERENCES memories(id) ON DELETE SET NULL,
+        source_memory_ids TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+    `);
+  }
+
+  // ---- Projects ----
+  async createProject(project: Project): Promise<Project> {
+    this.db.prepare(`INSERT INTO projects (id, name, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?)`).run(project.id, project.name, project.description ?? null, project.createdAt.toISOString(), project.updatedAt.toISOString());
+    return project;
+  }
+
+  async getProject(id: string): Promise<Project | null> {
+    const row = this.db.prepare(`SELECT * FROM projects WHERE id = ?`).get(id) as any;
+    if (!row) return null;
+    return this.mapProject(row);
+  }
+
+  async getProjectByName(name: string): Promise<Project | null> {
+    const row = this.db.prepare(`SELECT * FROM projects WHERE name = ?`).get(name) as any;
+    if (!row) return null;
+    return this.mapProject(row);
+  }
+
+  async listProjects(): Promise<Project[]> {
+    const rows = this.db.prepare(`SELECT * FROM projects`).all() as any[];
+    return rows.map(this.mapProject);
+  }
+
+  async deleteProject(projectId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM projects WHERE id = ?`).run(projectId);
+  }
+
+  // ---- Sources ----
+  async createSource(source: Source): Promise<Source> {
+    this.db.prepare(`INSERT INTO sources (id, project_id, type, content, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?)`).run(
+      source.id, source.projectId, source.type, source.content ?? null, source.createdAt.toISOString(), JSON.stringify(source.metadata)
+    );
+    return source;
+  }
+
+  async getSource(id: string): Promise<Source | null> {
+    const row = this.db.prepare(`SELECT * FROM sources WHERE id = ?`).get(id) as any;
+    if (!row) return null;
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      type: row.type,
+      content: row.content ?? undefined,
+      createdAt: new Date(row.created_at),
+      metadata: JSON.parse(row.metadata),
+    };
+  }
+
+  // ---- Memories ----
+  async createMemory(memory: Memory): Promise<void> {
+    this.db.prepare(`
+      INSERT INTO memories (id, project_id, type, content, importance, confidence, status, created_at, updated_at, last_accessed_at, access_count, source_id, metadata, archived)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      memory.id,
+      memory.projectId,
+      memory.type,
+      memory.content,
+      memory.importance,
+      memory.confidence ?? 1,
+      memory.status ?? "active",
+      memory.createdAt.toISOString(),
+      memory.updatedAt.toISOString(),
+      memory.lastAccessedAt ? memory.lastAccessedAt.toISOString() : null,
+      memory.accessCount,
+      memory.sourceId ?? null,
+      JSON.stringify(memory.metadata),
+      memory.archived ? 1 : 0
+    );
+  }
+
+  async getMemory(id: string): Promise<Memory | null> {
+    const row = this.db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id) as any;
+    if (!row) return null;
+    return this.mapMemory(row);
+  }
+
+  async updateMemory(id: string, update: Partial<Memory>): Promise<void> {
+    const existing = await this.getMemory(id);
+    if (!existing) return;
+    const merged: Memory = { ...existing, ...update, id, updatedAt: update.updatedAt ?? new Date() } as Memory;
+    this.db.prepare(`
+      UPDATE memories SET type=?, content=?, importance=?, confidence=?, status=?, created_at=?, updated_at=?, last_accessed_at=?, access_count=?, source_id=?, metadata=?, archived=?
+      WHERE id=?
+    `).run(
+      merged.type,
+      merged.content,
+      merged.importance,
+      merged.confidence,
+      (merged.status ?? "active"),
+      merged.createdAt.toISOString(),
+      merged.updatedAt.toISOString(),
+      merged.lastAccessedAt ? merged.lastAccessedAt.toISOString() : null,
+      merged.accessCount,
+      merged.sourceId ?? null,
+      JSON.stringify(merged.metadata),
+      merged.archived ? 1 : 0,
+      id
+    );
+  }
+
+  async deleteMemory(id: string): Promise<void> {
+    this.db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+  }
+
+  async archiveMemory(id: string): Promise<void> {
+    this.db.prepare(`UPDATE memories SET archived=1, status='archived', updated_at=? WHERE id=?`).run(new Date().toISOString(), id);
+  }
+
+  async listMemories(projectId: string): Promise<Memory[]> {
+    const rows = this.db.prepare(`SELECT * FROM memories WHERE project_id = ? ORDER BY updated_at DESC`).all(projectId) as any[];
+    return rows.map(this.mapMemory);
+  }
+
+  async search(query: SearchQuery): Promise<SearchResult[]> {
+    let sql = `SELECT * FROM memories WHERE project_id = ?`;
+    const params: any[] = [query.projectId];
+    if (query.types && query.types.length) {
+      sql += ` AND type IN (${query.types.map(() => "?").join(",")})`;
+      params.push(...query.types);
+    }
+    if (query.minImportance !== undefined) {
+      sql += ` AND importance >= ?`;
+      params.push(query.minImportance);
+    }
+    if (!query.includeArchived) {
+      sql += ` AND archived = 0 AND status != 'archived'`;
+    }
+    const rows = this.db.prepare(sql).all(...params) as any[];
+    const memories = rows.map(this.mapMemory);
+
+    const qLower = query.query.toLowerCase();
+    const qTokens = new Set(qLower.split(/\W+/).filter(Boolean));
+    const scored = memories.map((m) => {
+      const cLower = m.content.toLowerCase();
+      const cTokens = cLower.split(/\W+/).filter(Boolean);
+      let hits = 0;
+      for (const t of cTokens) if (qTokens.has(t)) hits++;
+      const phraseBoost = cLower.includes(qLower) ? 0.5 : 0;
+      const keywordScore = qTokens.size ? Math.min(1, hits / qTokens.size + phraseBoost) : 0;
+      const recency = Math.exp(-(Date.now() - m.updatedAt.getTime()) / (1000 * 60 * 60 * 24 * 30));
+      const final = keywordScore * 0.7 + m.importance * 0.15 + recency * 0.15;
+      return { memory: m, score: final, semanticScore: 0, keywordScore };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, query.limit ?? 5);
+  }
+
+  // ---- Embeddings ----
+  async upsertEmbedding(memoryId: string, vector: number[], model: string): Promise<void> {
+    this.db.prepare(`INSERT INTO embeddings (memory_id, vector, model, dimensions) VALUES (?, ?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector=excluded.vector, model=excluded.model, dimensions=excluded.dimensions
+    `).run(memoryId, JSON.stringify(vector), model, vector.length);
+  }
+
+  async getEmbedding(memoryId: string): Promise<{ vector: number[]; model: string } | null> {
+    const row = this.db.prepare(`SELECT * FROM embeddings WHERE memory_id = ?`).get(memoryId) as any;
+    if (!row) return null;
+    return { vector: JSON.parse(row.vector), model: row.model };
+  }
+
+  async deleteEmbedding(memoryId: string): Promise<void> {
+    this.db.prepare(`DELETE FROM embeddings WHERE memory_id = ?`).run(memoryId);
+  }
+
+  // ---- Retrieval logs ----
+  async logRetrieval(event: RetrievalEvent): Promise<void> {
+    this.db.prepare(`INSERT INTO retrieval_events (id, project_id, query, retrieved_memory_ids, scores, final_context_tokens, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(
+      event.id, event.projectId, event.query, JSON.stringify(event.retrievedMemoryIds), JSON.stringify(event.scores), event.finalContextTokens, event.createdAt.toISOString()
+    );
+  }
+
+  async listRetrievals(projectId: string, limit = 20): Promise<RetrievalEvent[]> {
+    const rows = this.db.prepare(`SELECT * FROM retrieval_events WHERE project_id = ? ORDER BY created_at DESC LIMIT ?`).all(projectId, limit) as any[];
+    return rows.map((r) => ({
+      id: r.id,
+      projectId: r.project_id,
+      query: r.query,
+      retrievedMemoryIds: JSON.parse(r.retrieved_memory_ids),
+      scores: JSON.parse(r.scores),
+      finalContextTokens: r.final_context_tokens,
+      createdAt: new Date(r.created_at),
+    }));
+  }
+
+  async close(): Promise<void> {
+    this.db.close();
+  }
+
+  private mapProject = (row: any): Project => ({
+    id: row.id,
+    name: row.name,
+    description: row.description ?? undefined,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  });
+
+  private mapMemory = (row: any): Memory => ({
+    id: row.id,
+    projectId: row.project_id,
+    type: row.type,
+    content: row.content,
+    importance: row.importance,
+    confidence: row.confidence,
+    status: row.status,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+    lastAccessedAt: row.last_accessed_at ? new Date(row.last_accessed_at) : undefined,
+    accessCount: row.access_count,
+    sourceId: row.source_id ?? undefined,
+    metadata: JSON.parse(row.metadata),
+    archived: !!row.archived,
+  });
+}

package/packages/storage/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": false
+  }
+}

package/test-mvp.mjs

@@ -0,0 +1,82 @@
+import { Memory } from "./dist/packages/core/src/memory.js";
+import { InMemoryStore } from "./dist/packages/storage/src/memory-store.js";
+import { SqliteMemoryStore } from "./dist/packages/storage/src/sqlite-store.js";
+import { LocalEmbeddingProvider } from "./dist/packages/embeddings/src/local.js";
+
+async function runTests() {
+  console.log("=== MVP Tests ===");
+
+  // Test 1: InMemoryStore + Local embeddings + basic remember/search
+  const store = new InMemoryStore();
+  const embed = new LocalEmbeddingProvider(64);
+  const memory = await Memory.create({ project: "research-mesh", store, embeddingProvider: embed });
+
+  await memory.remember({ type: "decision", content: "We decided to use PostgreSQL with pgvector.", importance: 0.9 });
+  await memory.remember({ type: "fact", content: "API-4821 is about payment gateway timeout.", importance: 0.8 });
+  await memory.remember({ type: "knowledge", content: "Backend uses Node.js and Fastify.", importance: 0.6 });
+
+  // Test search
+  const result = await memory.search("What database did we decide to use?");
+  console.log("Test 1 - Semantic search:", result.length > 0 ? "PASS" : "FAIL", "->", result[0]?.memory.content);
+  if (!result[0]?.memory.content.includes("PostgreSQL")) throw new Error("Search failed to retrieve PostgreSQL memory");
+
+  // Test hybrid keyword: API-4821
+  const kwResult = await memory.search("What's the status of API-4821?");
+  console.log("Test 2 - Hybrid keyword:", kwResult[0]?.memory.content.includes("API-4821") ? "PASS" : "FAIL", "->", kwResult[0]?.memory.content);
+
+  // Test context budgeting
+  const ctx = await memory.context({ query: "What database did we decide to use?", maxTokens: 6000 });
+  console.log("Test 3 - Context:", ctx.text.includes("PostgreSQL") ? "PASS" : "FAIL", `tokens=${ctx.tokenCount}`);
+  console.log("  text:", ctx.text.slice(0, 200));
+
+  // Test project isolation
+  const memoryB = await Memory.create({ project: "personal", store, embeddingProvider: embed });
+  await memoryB.remember({ type: "fact", content: "We use MongoDB for personal project.", importance: 0.9 });
+  const isolated = await memory.search("What database do we use?");
+  console.log("Test 4 - Project isolation:", isolated[0]?.memory.content.includes("PostgreSQL") && !isolated.some(r => r.memory.content.includes("MongoDB")) ? "PASS" : "FAIL", "->", isolated[0]?.memory.content);
+  const crossLeak = isolated.some(r => r.memory.projectId !== memory.project.id);
+  console.log("  cross-project leak:", crossLeak ? "FAIL" : "PASS");
+
+  // Test deduplication
+  const beforeCount = (await store.listMemories(memory.project.id)).length;
+  await memory.remember({ type: "decision", content: "We decided to use PostgreSQL with pgvector.", importance: 0.9 });
+  const afterCount = (await store.listMemories(memory.project.id)).length;
+  console.log("Test 5 - Deduplication:", beforeCount === afterCount ? "PASS" : "FAIL", `before=${beforeCount} after=${afterCount}`);
+
+  // Test conflict resolution
+  await memory.remember({ type: "decision", content: "We've switched to PostgreSQL with pgvector instead of MongoDB for production storage.", importance: 0.95 });
+  // should supersede any conflicting? Check statuses
+  const all = await store.listMemories(memory.project.id);
+  console.log("Test 6 - Conflict handling: memories", all.map(m => `${m.content.slice(0,30)} [${m.status}]`).join(" | "));
+
+  // Test token budgeting with many memories
+  for (let i = 0; i < 20; i++) {
+    await memory.remember({ content: `Fact ${i}: Lorem ipsum dolor sit amet consectetur adipiscing elit.`.repeat(5), importance: 0.5 });
+  }
+  const bigCtx = await memory.context({ query: "Fact", maxTokens: 100 });
+  console.log("Test 7 - Token budgeting:", bigCtx.tokenCount <= 100 ? "PASS" : "FAIL", `tokens=${bigCtx.tokenCount} limit=100`);
+
+  // Test Sqlite store (node:sqlite)
+  console.log("\n=== SQLite Store Test ===");
+  const sqliteStore = new SqliteMemoryStore({ path: ":memory:" });
+  const sqliteMemory = await Memory.create({ project: "sqlite-test", store: sqliteStore, embeddingProvider: embed });
+  await sqliteMemory.remember({ content: "SQLite test memory with PostgreSQL pgvector", importance: 0.9 });
+  const sqliteSearch = await sqliteMemory.search("PostgreSQL");
+  console.log("SQLite search:", sqliteSearch[0]?.memory.content.includes("PostgreSQL") ? "PASS" : "FAIL");
+  await sqliteStore.close();
+
+  // Test goldfish & cross-project leakage eval
+  console.log("\n=== Evaluation Tests ===");
+  const evalStore = new InMemoryStore();
+  const projA = await Memory.create({ project: "project-a", store: evalStore, embeddingProvider: embed });
+  const projB = await Memory.create({ project: "project-b", store: evalStore, embeddingProvider: embed });
+  await projA.remember({ content: "We use PostgreSQL.", importance: 0.9 });
+  await projB.remember({ content: "We use MongoDB.", importance: 0.9 });
+  const queryA = await projA.search("What database do we use?");
+  console.log("Goldfish cross-project:", queryA[0]?.memory.content.includes("PostgreSQL") ? "PASS" : "FAIL", "->", queryA[0]?.memory.content);
+  console.log("Cross-project leakage (should be 0):", queryA.some(r => r.memory.content.includes("MongoDB")) ? "FAIL" : "PASS");
+
+  console.log("\n=== All MVP tests completed ===");
+}
+
+runTests().catch(e => { console.error(e); process.exit(1); });