@slorenzot/memento-core 0.1.0

package/drizzle.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+  schema: './src/db/schema.ts',
+  out: './src/db/migrations',
+  driver: 'better-sqlite',
+  dbCredentials: {
+    url: './data/memento.db',
+  },
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@slorenzot/memento-core",
+  "version": "0.1.0",
+  "description": "Core memory engine for Memento",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "dev": "bun tsc --watch",
+    "build": "bun tsc --declaration --declarationMap --emitDeclarationOnly --outDir ./dist",
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "zod": "^3.22.4",
+    "nanoid": "^5.0.4"
+  },
+  "devDependencies": {
+    "bun-types": "^1.3.11"
+  }
+}

package/src/MemoryEngine.test.ts

@@ -0,0 +1,394 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
+import { MemoryEngine } from './MemoryEngine';
+import type { Observation, Session, Prompt } from './types';
+
+describe('MemoryEngine', () => {
+  let engine: MemoryEngine;
+  let testDbPath: string;
+
+  beforeEach(() => {
+    testDbPath = `/tmp/test-memento-${Date.now()}.db`;
+    engine = new MemoryEngine(testDbPath);
+  });
+
+  afterEach(() => {
+    engine.close();
+  });
+
+  describe('Session Management', () => {
+    it('should create a session successfully', async () => {
+      const session = await engine.createSession({
+        projectId: 'test-project',
+        endedAt: null,
+        metadata: { agent: 'test-agent' },
+      });
+
+      expect(session).toBeDefined();
+      expect(session.id).toBeDefined();
+      expect(session.uuid).toBeDefined();
+      expect(session.projectId).toBe('test-project');
+      expect(session.metadata).toEqual({ agent: 'test-agent' });
+    });
+
+    it('should get a session by id', async () => {
+      const created = await engine.createSession({
+        projectId: 'test-project',
+        endedAt: null,
+        metadata: {},
+      });
+
+      const retrieved = await engine.getSession(created.id);
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(created.id);
+      expect(retrieved?.uuid).toBe(created.uuid);
+    });
+
+    it('should end a session', async () => {
+      const session = await engine.createSession({
+        projectId: 'test-project',
+        endedAt: null,
+        metadata: {},
+      });
+
+      expect(session.endedAt).toBeNull();
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const ended = await engine.endSession(session.id);
+
+      expect(ended.endedAt).not.toBeNull();
+      expect(ended.endedAt?.getTime()).toBeGreaterThan(session.startedAt.getTime());
+    });
+
+    it('should return null for non-existent session', async () => {
+      const session = await engine.getSession(99999);
+      expect(session).toBeNull();
+    });
+  });
+
+  describe('Observation Management', () => {
+    let session: Session;
+
+    beforeEach(async () => {
+      session = await engine.createSession({
+        projectId: 'test-project',
+        endedAt: null,
+        metadata: {},
+      });
+    });
+
+    it('should create an observation successfully', async () => {
+      const observation = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Test Decision',
+        content: 'This is a test decision',
+        type: 'decision',
+        topicKey: 'test-topic',
+        projectId: 'test-project',
+        metadata: { source: 'test' },
+      });
+
+      expect(observation).toBeDefined();
+      expect(observation.id).toBeDefined();
+      expect(observation.title).toBe('Test Decision');
+      expect(observation.type).toBe('decision');
+      expect(observation.sessionId).toBe(session.id);
+    });
+
+    it('should get an observation by id', async () => {
+      const created = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Get Test',
+        content: 'Get this observation',
+        type: 'note',
+        topicKey: 'get-topic',
+        projectId: 'test-project',
+        metadata: {},
+      });
+
+      const retrieved = await engine.getObservation(created.id);
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(created.id);
+      expect(retrieved?.title).toBe('Get Test');
+    });
+
+    it('should update an observation', async () => {
+      const created = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Original Title',
+        content: 'Original content',
+        type: 'decision',
+        topicKey: 'update-topic',
+        projectId: 'test-project',
+        metadata: {},
+      });
+
+      const updated = await engine.updateObservation(created.id, {
+        title: 'Updated Title',
+        content: 'Updated content',
+      });
+
+      expect(updated.title).toBe('Updated Title');
+      expect(updated.content).toBe('Updated content');
+      expect(updated.type).toBe('decision');
+    });
+
+    it('should delete an observation', async () => {
+      const created = await engine.createObservation({
+        sessionId: session.id,
+        title: 'To Delete',
+        content: 'This will be deleted',
+        type: 'note',
+        topicKey: 'delete-topic',
+        projectId: 'test-project',
+        metadata: {},
+      });
+
+      await engine.deleteObservation(created.id);
+
+      const retrieved = await engine.getObservation(created.id);
+      expect(retrieved).toBeNull();
+    });
+
+    it('should return null for non-existent observation', async () => {
+      const observation = await engine.getObservation(99999);
+      expect(observation).toBeNull();
+    });
+
+    it('should handle all observation types', async () => {
+      const types: Array<Observation['type']> = ['decision', 'bug', 'discovery', 'note'];
+
+      for (const type of types) {
+        const observation = await engine.createObservation({
+          sessionId: session.id,
+          title: `${type} Observation`,
+          content: `Content for ${type}`,
+          type,
+          topicKey: `${type}-topic`,
+          projectId: 'test-project',
+          metadata: {},
+        });
+
+        expect(observation.type).toBe(type);
+      }
+    });
+
+    it('should handle null topic key', async () => {
+      const observation = await engine.createObservation({
+        sessionId: session.id,
+        title: 'No Topic',
+        content: 'This has no topic',
+        type: 'note',
+        topicKey: null,
+        projectId: 'test-project',
+        metadata: {},
+      });
+
+      expect(observation.topicKey).toBeNull();
+    });
+  });
+
+  describe('Prompt Management', () => {
+    let session: Session;
+
+    beforeEach(async () => {
+      session = await engine.createSession({
+        projectId: 'test-project',
+        endedAt: null,
+        metadata: {},
+      });
+    });
+
+    it('should save a prompt successfully', async () => {
+      const prompt = await engine.savePrompt({
+        sessionId: session.id,
+        content: 'This is a test prompt',
+        projectId: 'test-project',
+        metadata: { length: 21 },
+      });
+
+      expect(prompt).toBeDefined();
+      expect(prompt.id).toBeDefined();
+      expect(prompt.content).toBe('This is a test prompt');
+      expect(prompt.sessionId).toBe(session.id);
+      expect(prompt.metadata).toEqual({ length: 21 });
+    });
+  });
+
+  describe('Search Functionality', () => {
+    let session: Session;
+
+    beforeEach(async () => {
+      session = await engine.createSession({
+        projectId: 'search-project',
+        endedAt: null,
+        metadata: {},
+      });
+
+      await engine.createObservation({
+        sessionId: session.id,
+        title: 'Authentication Fix',
+        content: 'Fixed the JWT authentication bug',
+        type: 'bug',
+        topicKey: 'auth',
+        projectId: 'search-project',
+        metadata: {},
+      });
+
+      await engine.createObservation({
+        sessionId: session.id,
+        title: 'Performance Decision',
+        content: 'Decided to use Redis for caching',
+        type: 'decision',
+        topicKey: 'performance',
+        projectId: 'search-project',
+        metadata: {},
+      });
+
+      await engine.createObservation({
+        sessionId: session.id,
+        title: 'Database Discovery',
+        content: 'Found a better way to query the database',
+        type: 'discovery',
+        topicKey: 'database',
+        projectId: 'search-project',
+        metadata: {},
+      });
+    });
+
+    it('should search all observations', async () => {
+      const result = await engine.search({});
+
+      expect(result.observations.length).toBeGreaterThanOrEqual(3);
+      expect(result.total).toBeGreaterThanOrEqual(3);
+    });
+
+    it('should search by type', async () => {
+      const result = await engine.search({ type: 'bug' });
+
+      expect(result.observations).toHaveLength(1);
+      expect(result.observations[0].type).toBe('bug');
+      expect(result.observations[0].title).toContain('Authentication');
+    });
+
+    it('should search by project id', async () => {
+      const result = await engine.search({ projectId: 'search-project' });
+
+      expect(result.observations.length).toBeGreaterThanOrEqual(3);
+      result.observations.forEach((obs) => {
+        expect(obs.projectId).toBe('search-project');
+      });
+    });
+
+    it('should search by topic key', async () => {
+      const result = await engine.search({ topicKey: 'auth' });
+
+      expect(result.observations).toHaveLength(1);
+      expect(result.observations[0].topicKey).toBe('auth');
+    });
+
+    it('should limit results', async () => {
+      const result = await engine.search({ limit: 2 });
+
+      expect(result.observations.length).toBeLessThanOrEqual(2);
+    });
+
+    it('should offset results', async () => {
+      const firstPage = await engine.search({ limit: 2, offset: 0 });
+      const secondPage = await engine.search({ limit: 2, offset: 2 });
+
+      expect(firstPage.observations.length).toBe(2);
+      if (secondPage.observations.length > 0) {
+        const firstIds = firstPage.observations.map((o) => o.id);
+        const secondIds = secondPage.observations.map((o) => o.id);
+        expect(firstIds).not.toEqual(secondIds);
+      }
+    });
+
+    it('should return correct total count', async () => {
+      const result = await engine.search({ projectId: 'search-project' });
+
+      expect(result.total).toBe(result.observations.length);
+    });
+
+    it('should handle empty search results', async () => {
+      const result = await engine.search({
+        projectId: 'non-existent-project',
+      });
+
+      expect(result.observations).toHaveLength(0);
+      expect(result.total).toBe(0);
+    });
+  });
+
+  describe('Metadata Handling', () => {
+    let session: Session;
+
+    beforeEach(async () => {
+      session = await engine.createSession({
+        projectId: 'metadata-project',
+        endedAt: null,
+        metadata: {},
+      });
+    });
+
+    it('should serialize and deserialize complex metadata', async () => {
+      const complexMetadata = {
+        nested: {
+          array: [1, 2, 3],
+          object: { key: 'value' },
+        },
+        string: 'test',
+        number: 42,
+        boolean: true,
+        nullValue: null,
+      };
+
+      const observation = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Complex Metadata',
+        content: 'Testing metadata serialization',
+        type: 'note',
+        topicKey: 'metadata',
+        projectId: 'metadata-project',
+        metadata: complexMetadata,
+      });
+
+      expect(observation.metadata).toEqual(complexMetadata);
+    });
+
+    it('should handle empty metadata', async () => {
+      const observation = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Empty Metadata',
+        content: 'No metadata here',
+        type: 'note',
+        topicKey: 'empty',
+        projectId: 'metadata-project',
+        metadata: {},
+      });
+
+      expect(observation.metadata).toEqual({});
+    });
+
+    it('should update metadata', async () => {
+      const created = await engine.createObservation({
+        sessionId: session.id,
+        title: 'Update Metadata Test',
+        content: 'Will update metadata',
+        type: 'note',
+        topicKey: 'update',
+        projectId: 'metadata-project',
+        metadata: { version: 1 },
+      });
+
+      const updated = await engine.updateObservation(created.id, {
+        metadata: { version: 2, changed: true },
+      });
+
+      expect(updated.metadata).toEqual({ version: 2, changed: true });
+    });
+  });
+});

package/src/MemoryEngine.ts

@@ -0,0 +1,442 @@
+import Database from 'bun:sqlite';
+import { nanoid } from 'nanoid';
+import type { Observation, Session, Prompt } from './types';
+
+export class MemoryEngine {
+  private db: Database;
+
+  constructor(dbPath: string = './data/memento.db') {
+    this.db = new Database(dbPath, { create: true });
+    this.initializeDatabase();
+  }
+
+  private initializeDatabase(): void {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA foreign_keys = ON;
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        uuid TEXT UNIQUE NOT NULL,
+        project_id TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        metadata TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS observations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        uuid TEXT UNIQUE NOT NULL,
+        session_id INTEGER NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        type TEXT NOT NULL,
+        topic_key TEXT,
+        project_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        metadata TEXT,
+        FOREIGN KEY (session_id) REFERENCES sessions(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS prompts (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        uuid TEXT UNIQUE NOT NULL,
+        session_id INTEGER NOT NULL,
+        content TEXT NOT NULL,
+        project_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        metadata TEXT,
+        FOREIGN KEY (session_id) REFERENCES sessions(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        created_at INTEGER NOT NULL,
+        metadata TEXT
+      );
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS observations_fts USING fts5(
+        title, content, topic_key, project_id,
+        content='observations'
+      );
+
+      CREATE TRIGGER IF NOT EXISTS observations_ai AFTER INSERT ON observations BEGIN
+        INSERT INTO observations_fts(rowid, title, content, topic_key, project_id)
+        VALUES (new.id, new.title, new.content, new.topic_key, new.project_id);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS observations_ad AFTER DELETE ON observations BEGIN
+        DELETE FROM observations_fts WHERE rowid = old.id;
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS observations_au AFTER UPDATE ON observations BEGIN
+        DELETE FROM observations_fts WHERE rowid = old.id;
+        INSERT INTO observations_fts(rowid, title, content, topic_key, project_id)
+        VALUES (new.id, new.title, new.content, new.topic_key, new.project_id);
+      END;
+    `);
+  }
+
+  private serialize(value: unknown): string {
+    return JSON.stringify(value);
+  }
+
+  private deserialize(value: string | null): Record<string, unknown> {
+    if (!value) {
+      return {};
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      return {};
+    }
+  }
+
+  async createObservation(data: {
+    sessionId: number;
+    title: string;
+    content: string;
+    type: Observation['type'];
+    topicKey: string | null;
+    projectId: string;
+    metadata: Record<string, unknown>;
+  }): Promise<Observation> {
+    const uuid = nanoid();
+    const createdAt = new Date();
+    const metadata = this.serialize(data.metadata);
+
+    const stmt = this.db.prepare(
+      `INSERT INTO observations (uuid, session_id, title, content, type, topic_key, project_id, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING id`
+    );
+
+    const result = stmt.get(
+      uuid,
+      data.sessionId,
+      data.title,
+      data.content,
+      data.type,
+      data.topicKey ?? null,
+      data.projectId,
+      createdAt.getTime(),
+      metadata
+    ) as { id: number };
+
+    if (!result) {
+      throw new Error('Failed to create observation');
+    }
+
+    const observation = await this.getObservationById(result.id);
+    if (!observation) {
+      throw new Error('Failed to retrieve created observation');
+    }
+
+    return observation;
+  }
+
+  async updateObservation(
+    id: number,
+    updates: {
+      title?: string;
+      content?: string;
+      type?: Observation['type'];
+      topicKey?: string | null;
+      metadata?: Record<string, unknown>;
+    }
+  ): Promise<Observation> {
+    const current = await this.getObservationById(id);
+    if (!current) {
+      throw new Error('Observation not found');
+    }
+
+    const fields: string[] = [];
+    const values: (string | number | null)[] = [];
+
+    if (updates.title !== undefined) {
+      fields.push('title = ?');
+      values.push(updates.title);
+    }
+    if (updates.content !== undefined) {
+      fields.push('content = ?');
+      values.push(updates.content);
+    }
+    if (updates.type !== undefined) {
+      fields.push('type = ?');
+      values.push(updates.type);
+    }
+    if (updates.topicKey !== undefined) {
+      fields.push('topic_key = ?');
+      values.push(updates.topicKey || '');
+    }
+    if (updates.metadata !== undefined) {
+      fields.push('metadata = ?');
+      values.push(this.serialize(updates.metadata));
+    }
+
+    if (fields.length === 0) {
+      return current;
+    }
+
+    values.push(id);
+    this.db.prepare(`UPDATE observations SET ${fields.join(', ')} WHERE id = ?`).run(...values);
+
+    const updated = await this.getObservationById(id);
+    if (!updated) {
+      throw new Error('Failed to update observation');
+    }
+
+    return updated;
+  }
+
+  async deleteObservation(id: number): Promise<void> {
+    this.db.prepare('DELETE FROM observations WHERE id = ?').run(id);
+  }
+
+  async getObservation(id: number): Promise<Observation | null> {
+    return await this.getObservationById(id);
+  }
+
+  async search(params: {
+    query?: string;
+    type?: Observation['type'];
+    projectId?: string;
+    topicKey?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<{ observations: Observation[]; total: number }> {
+    const { query, type, projectId, topicKey, limit = 100, offset = 0 } = params;
+
+    let sql = 'SELECT * FROM observations WHERE 1=1';
+    const values: (string | number | null)[] = [];
+
+    if (query) {
+      sql += ' AND observations_fts MATCH ?';
+      values.push(query);
+    }
+
+    if (type) {
+      sql += ' AND type = ?';
+      values.push(type);
+    }
+
+    if (projectId) {
+      sql += ' AND project_id = ?';
+      values.push(projectId);
+    }
+
+    if (topicKey) {
+      sql += ' AND topic_key = ?';
+      values.push(topicKey);
+    }
+
+    const countSql = sql.replace('SELECT *', 'SELECT COUNT(*) as count');
+    const countResult = this.db.query(countSql).get(...values);
+    const total = countResult ? (countResult as { count: number }).count : 0;
+
+    sql += ' ORDER BY created_at DESC LIMIT ? OFFSET ?';
+    values.push(limit, offset);
+
+    const stmt = this.db.query(sql);
+    const rows = stmt.all(...values);
+    const observations = rows.map((row) => this.mapObservation(row as Record<string, unknown>));
+
+    return { observations, total };
+  }
+
+  async createSession(data: {
+    projectId: string;
+    endedAt: Date | null;
+    metadata: Record<string, unknown>;
+  }): Promise<Session> {
+    const uuid = nanoid();
+    const startedAt = new Date();
+    const metadata = this.serialize(data.metadata);
+
+    const stmt = this.db.prepare(
+      `INSERT INTO sessions (uuid, project_id, started_at, ended_at, metadata) VALUES (?, ?, ?, ?, ?) RETURNING id`
+    );
+
+    const result = stmt.get(
+      uuid,
+      data.projectId,
+      startedAt.getTime(),
+      data.endedAt?.getTime() ?? null,
+      metadata
+    ) as { id: number };
+
+    if (!result) {
+      throw new Error('Failed to create session');
+    }
+
+    const session = await this.getSessionById(result.id);
+    if (!session) {
+      throw new Error('Failed to retrieve created session');
+    }
+
+    return session;
+  }
+
+  async endSession(id: number): Promise<Session> {
+    const session = await this.getSessionById(id);
+    if (!session) {
+      throw new Error('Session not found');
+    }
+
+    const endedAt = new Date();
+    this.db.prepare('UPDATE sessions SET ended_at = ? WHERE id = ?').run(endedAt.getTime(), id);
+
+    const updated = await this.getSessionById(id);
+    if (!updated) {
+      throw new Error('Failed to update session');
+    }
+
+    return updated;
+  }
+
+  async getSession(id: number): Promise<Session | null> {
+    return await this.getSessionById(id);
+  }
+
+  async savePrompt(data: {
+    sessionId: number;
+    content: string;
+    projectId: string;
+    metadata: Record<string, unknown>;
+  }): Promise<Prompt> {
+    const uuid = nanoid();
+    const createdAt = new Date();
+    const metadata = this.serialize(data.metadata);
+
+    const stmt = this.db.prepare(
+      `INSERT INTO prompts (uuid, session_id, content, project_id, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?) RETURNING id`
+    );
+
+    const result = stmt.get(
+      uuid,
+      data.sessionId,
+      data.content,
+      data.projectId,
+      createdAt.getTime(),
+      metadata
+    ) as { id: number };
+
+    if (!result) {
+      throw new Error('Failed to save prompt');
+    }
+
+    const prompt = await this.getPromptById(result.id);
+
+    if (!prompt) {
+      throw new Error('Failed to retrieve saved prompt');
+    }
+
+    return prompt;
+  }
+
+  private async getObservationById(id: number): Promise<Observation | null> {
+    const stmt = this.db.prepare('SELECT * FROM observations WHERE id = ?');
+    const row = stmt.get(id);
+
+    if (!row) {
+      return null;
+    }
+
+    return this.mapObservation(row as Record<string, unknown>);
+  }
+
+  private async getSessionById(id: number): Promise<Session | null> {
+    const stmt = this.db.prepare('SELECT * FROM sessions WHERE id = ?');
+    const row = stmt.get(id);
+
+    if (!row) {
+      return null;
+    }
+
+    return this.mapSession(row as Record<string, unknown>);
+  }
+
+  private async getPromptById(id: number): Promise<Prompt | null> {
+    const stmt = this.db.prepare('SELECT * FROM prompts WHERE id = ?');
+    const row = stmt.get(id);
+
+    if (!row) {
+      return null;
+    }
+
+    return this.mapPrompt(row as Record<string, unknown>);
+  }
+
+  private mapObservation(row: Record<string, unknown>): Observation {
+    const r = row as {
+      id: number;
+      uuid: string;
+      session_id: number;
+      title: string;
+      content: string;
+      type: Observation['type'];
+      topic_key: string | null;
+      project_id: string;
+      created_at: number;
+      metadata: string | null;
+    };
+
+    return {
+      id: r.id,
+      uuid: r.uuid,
+      sessionId: r.session_id,
+      title: r.title,
+      content: r.content,
+      type: r.type,
+      topicKey: r.topic_key,
+      projectId: r.project_id,
+      createdAt: new Date(r.created_at),
+      metadata: this.deserialize(r.metadata),
+    };
+  }
+
+  private mapSession(row: Record<string, unknown>): Session {
+    const r = row as {
+      id: number;
+      uuid: string;
+      project_id: string;
+      started_at: number;
+      ended_at: number | null;
+      metadata: string | null;
+    };
+
+    return {
+      id: r.id,
+      uuid: r.uuid,
+      projectId: r.project_id,
+      startedAt: new Date(r.started_at),
+      endedAt: r.ended_at ? new Date(r.ended_at) : null,
+      metadata: this.deserialize(r.metadata),
+    };
+  }
+
+  private mapPrompt(row: Record<string, unknown>): Prompt {
+    const r = row as {
+      id: number;
+      uuid: string;
+      session_id: number;
+      content: string;
+      project_id: string;
+      created_at: number;
+      metadata: string | null;
+    };
+
+    return {
+      id: r.id,
+      uuid: r.uuid,
+      sessionId: r.session_id,
+      content: r.content,
+      projectId: r.project_id,
+      createdAt: new Date(r.created_at),
+      metadata: this.deserialize(r.metadata),
+    };
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/db/schema.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projects = exports.prompts = exports.observations = exports.sessions = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+exports.sessions = (0, sqlite_core_1.sqliteTable)('sessions', {
+    id: (0, sqlite_core_1.integer)('id').primaryKey({ autoIncrement: true }),
+    uuid: (0, sqlite_core_1.text)('uuid').unique().notNull(),
+    projectId: (0, sqlite_core_1.text)('project_id').notNull(),
+    startedAt: (0, sqlite_core_1.integer)('started_at').notNull(),
+    endedAt: (0, sqlite_core_1.integer)('ended_at'),
+    metadata: (0, sqlite_core_1.text)('metadata'),
+});
+exports.observations = (0, sqlite_core_1.sqliteTable)('observations', {
+    id: (0, sqlite_core_1.integer)('id').primaryKey({ autoIncrement: true }),
+    uuid: (0, sqlite_core_1.text)('uuid').unique().notNull(),
+    sessionId: (0, sqlite_core_1.integer)('session_id').notNull(),
+    title: (0, sqlite_core_1.text)('title').notNull(),
+    content: (0, sqlite_core_1.text)('content').notNull(),
+    type: (0, sqlite_core_1.text)('type').notNull(),
+    topicKey: (0, sqlite_core_1.text)('topic_key'),
+    projectId: (0, sqlite_core_1.text)('project_id').notNull(),
+    createdAt: (0, sqlite_core_1.integer)('created_at').notNull(),
+    metadata: (0, sqlite_core_1.text)('metadata'),
+});
+exports.prompts = (0, sqlite_core_1.sqliteTable)('prompts', {
+    id: (0, sqlite_core_1.integer)('id').primaryKey({ autoIncrement: true }),
+    uuid: (0, sqlite_core_1.text)('uuid').unique().notNull(),
+    sessionId: (0, sqlite_core_1.integer)('session_id').notNull(),
+    content: (0, sqlite_core_1.text)('content').notNull(),
+    projectId: (0, sqlite_core_1.text)('project_id').notNull(),
+    createdAt: (0, sqlite_core_1.integer)('created_at').notNull(),
+    metadata: (0, sqlite_core_1.text)('metadata'),
+});
+exports.projects = (0, sqlite_core_1.sqliteTable)('projects', {
+    id: (0, sqlite_core_1.integer)('id').primaryKey({ autoIncrement: true }),
+    name: (0, sqlite_core_1.text)('name').unique().notNull(),
+    createdAt: (0, sqlite_core_1.integer)('created_at').notNull(),
+    metadata: (0, sqlite_core_1.text)('metadata'),
+});

package/src/db/schema.ts

@@ -0,0 +1,40 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
+
+export const sessions = sqliteTable('sessions', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  uuid: text('uuid').unique().notNull(),
+  projectId: text('project_id').notNull(),
+  startedAt: integer('started_at').notNull(),
+  endedAt: integer('ended_at'),
+  metadata: text('metadata'),
+});
+
+export const observations = sqliteTable('observations', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  uuid: text('uuid').unique().notNull(),
+  sessionId: integer('session_id').notNull(),
+  title: text('title').notNull(),
+  content: text('content').notNull(),
+  type: text('type').notNull(),
+  topicKey: text('topic_key'),
+  projectId: text('project_id').notNull(),
+  createdAt: integer('created_at').notNull(),
+  metadata: text('metadata'),
+});
+
+export const prompts = sqliteTable('prompts', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  uuid: text('uuid').unique().notNull(),
+  sessionId: integer('session_id').notNull(),
+  content: text('content').notNull(),
+  projectId: text('project_id').notNull(),
+  createdAt: integer('created_at').notNull(),
+  metadata: text('metadata'),
+});
+
+export const projects = sqliteTable('projects', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  name: text('name').unique().notNull(),
+  createdAt: integer('created_at').notNull(),
+  metadata: text('metadata'),
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './MemoryEngine';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,52 @@
+export interface Observation {
+  id: number;
+  uuid: string;
+  sessionId: number;
+  title: string;
+  content: string;
+  type: 'decision' | 'bug' | 'discovery' | 'note';
+  topicKey: string | null;
+  projectId: string;
+  createdAt: Date;
+  metadata: Record<string, unknown>;
+}
+
+export interface Session {
+  id: number;
+  uuid: string;
+  projectId: string;
+  startedAt: Date;
+  endedAt: Date | null;
+  metadata: Record<string, unknown>;
+}
+
+export interface Prompt {
+  id: number;
+  uuid: string;
+  sessionId: number;
+  content: string;
+  projectId: string;
+  createdAt: Date;
+  metadata: Record<string, unknown>;
+}
+
+export interface Project {
+  id: number;
+  name: string;
+  createdAt: Date;
+  metadata: Record<string, unknown>;
+}
+
+export interface SearchParams {
+  query?: string;
+  type?: Observation['type'];
+  projectId?: string;
+  topicKey?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface SearchResult {
+  observations: Observation[];
+  total: number;
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "noUncheckedIndexedAccess": false,
+    "noImplicitOverride": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.test.tsx"]
+}

package/tsconfig.json.bak

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "checkJs": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "incremental": true
+  },
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.test.tsx", "packages/web-ui"]
+}