agent-office 0.3.2 → 0.4.0

package/dist/server/memory.js

@@ -1,348 +0,0 @@
-import { createAgentMemory } from "fastmemory";
-import { mkdirSync, existsSync } from "fs";
-import { join, resolve } from "path";
-import Database from "better-sqlite3";
-/**
- * Abstract base class for agent memory backends.
- * Consumers should depend on this type rather than any concrete implementation.
- */
-export class AgentOfficeMemory {
-}
-// ── AgentOfficeSimpleMemory ───────────────────────────────────────────────────
-/**
- * Lightweight memory backend using a single SQLite database file at
- * <memoryPath>/simple-memory.db.  All sessions share the same file; rows are
- * partitioned by session_name.  Full-text search is provided by SQLite's
- * built-in FTS5 (BM25 ranking).  No embeddings, no external dependencies
- * beyond better-sqlite3.
- *
- * Activate with: agent-office serve --simple-memory
- */
-export class AgentOfficeSimpleMemory extends AgentOfficeMemory {
-    basePath;
-    db;
-    constructor(memoryPath) {
-        super();
-        this.basePath = resolve(memoryPath);
-        if (!existsSync(this.basePath)) {
-            mkdirSync(this.basePath, { recursive: true });
-        }
-        const dbPath = join(this.basePath, "simple-memory.db");
-        this.db = new Database(dbPath);
-        this.db.pragma("journal_mode = WAL");
-        this.db.pragma("foreign_keys = ON");
-        this._migrate();
-    }
-    _migrate() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memories (
-        id          TEXT PRIMARY KEY,
-        session_name TEXT NOT NULL,
-        content     TEXT NOT NULL,
-        metadata    TEXT NOT NULL DEFAULT '{}',
-        created_at  TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS memories_session_idx ON memories (session_name);
-
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-        content,
-        session_name UNINDEXED,
-        memory_id UNINDEXED,
-        content='memories',
-        content_rowid='rowid',
-        tokenize='porter unicode61'
-      );
-
-      CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-        INSERT INTO memories_fts(rowid, content, session_name, memory_id)
-          VALUES (new.rowid, new.content, new.session_name, new.id);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, content, session_name, memory_id)
-          VALUES ('delete', old.rowid, old.content, old.session_name, old.id);
-      END;
-
-      CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-        INSERT INTO memories_fts(memories_fts, rowid, content, session_name, memory_id)
-          VALUES ('delete', old.rowid, old.content, old.session_name, old.id);
-        INSERT INTO memories_fts(rowid, content, session_name, memory_id)
-          VALUES (new.rowid, new.content, new.session_name, new.id);
-      END;
-    `);
-    }
-    newId() {
-        // Compact random UUID without hyphens
-        return crypto.randomUUID().replace(/-/g, "");
-    }
-    sanitizeFts5Query(query) {
-        return query
-            .split(/\s+/)
-            .filter((t) => t.length > 0)
-            .map((t) => `"${t.replace(/"/g, '""')}"`)
-            .join(" ");
-    }
-    async addMemory(sessionName, content, metadata = {}) {
-        const id = this.newId();
-        const createdAt = new Date().toISOString();
-        this.db.prepare(`INSERT INTO memories (id, session_name, content, metadata, created_at) VALUES (?, ?, ?, ?, ?)`).run(id, sessionName, content, JSON.stringify(metadata), createdAt);
-        return id;
-    }
-    async searchMemories(sessionName, query, limit = 10) {
-        if (!query.trim())
-            return [];
-        const safeQuery = this.sanitizeFts5Query(query);
-        const rows = this.db.prepare(`
-      SELECT m.id, m.content, m.metadata, m.created_at,
-             -bm25(memories_fts) AS score
-        FROM memories_fts
-        JOIN memories m ON m.id = memories_fts.memory_id
-       WHERE memories_fts MATCH ?
-         AND memories_fts.session_name = ?
-       ORDER BY score DESC
-       LIMIT ?
-    `).all(safeQuery, sessionName, limit);
-        return rows.map((r) => ({
-            id: r.id,
-            content: r.content,
-            metadata: r.metadata ? JSON.parse(r.metadata) : {},
-            createdAt: r.created_at,
-            score: r.score,
-        }));
-    }
-    listMemories(sessionName, limit = 50) {
-        const rows = this.db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE session_name = ? ORDER BY created_at DESC LIMIT ?`).all(sessionName, limit);
-        return rows.map((r) => ({
-            id: r.id,
-            content: r.content,
-            metadata: r.metadata ? JSON.parse(r.metadata) : {},
-            createdAt: r.created_at,
-        }));
-    }
-    getMemory(sessionName, memoryId) {
-        const row = this.db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE id = ? AND session_name = ?`).get(memoryId, sessionName);
-        if (!row)
-            return null;
-        return {
-            id: row.id,
-            content: row.content,
-            metadata: row.metadata ? JSON.parse(row.metadata) : {},
-            createdAt: row.created_at,
-        };
-    }
-    deleteMemory(sessionName, memoryId) {
-        const result = this.db.prepare(`DELETE FROM memories WHERE id = ? AND session_name = ?`).run(memoryId, sessionName);
-        return result.changes > 0;
-    }
-    async updateMemory(sessionName, memoryId, content, metadata) {
-        const existing = this.getMemory(sessionName, memoryId);
-        if (!existing)
-            return false;
-        const finalMetadata = metadata ?? existing.metadata;
-        const result = this.db.prepare(`UPDATE memories SET content = ?, metadata = ? WHERE id = ? AND session_name = ?`).run(content, JSON.stringify(finalMetadata), memoryId, sessionName);
-        return result.changes > 0;
-    }
-    getStats(sessionName) {
-        const row = this.db.prepare(`SELECT COUNT(*) as total FROM memories WHERE session_name = ?`).get(sessionName);
-        return { total: row.total };
-    }
-    async warmup() {
-        // No model to warm up — DB is already open and ready.
-    }
-    closeAll() {
-        try {
-            this.db.close();
-        }
-        catch { /* ignore */ }
-    }
-}
-/**
- * Concrete AgentOfficeMemory implementation backed by fastmemory (SQLite + embeddings).
- * Each session gets its own .db file under <memoryPath>/<sessionName>.db
- */
-export class AgentOfficeFastMemory extends AgentOfficeMemory {
-    basePath;
-    stores = new Map();
-    constructor(memoryPath) {
-        super();
-        this.basePath = resolve(memoryPath);
-        if (!existsSync(this.basePath)) {
-            mkdirSync(this.basePath, { recursive: true });
-        }
-    }
-    dbPathFor(sessionName) {
-        // Sanitize session name for filesystem safety
-        const safe = sessionName.replace(/[^a-zA-Z0-9_-]/g, "_");
-        return join(this.basePath, `${safe}.db`);
-    }
-    async getStore(sessionName) {
-        if (this.stores.has(sessionName)) {
-            return this.stores.get(sessionName);
-        }
-        const dbPath = this.dbPathFor(sessionName);
-        const cacheDir = join(this.basePath, ".model-cache");
-        const store = await createAgentMemory({
-            dbPath,
-            cacheDir,
-            dtype: "q4",
-        });
-        this.stores.set(sessionName, store);
-        return store;
-    }
-    async addMemory(sessionName, content, metadata = {}) {
-        const store = await this.getStore(sessionName);
-        return await store.add(content, metadata);
-    }
-    /**
-     * Sanitize a query string for FTS5 MATCH syntax.
-     * Wraps each whitespace-delimited token in double quotes so that
-     * special characters (apostrophes, parens, asterisks, etc.) are
-     * treated as literals rather than FTS5 operators.
-     */
-    sanitizeFts5Query(query) {
-        return query
-            .split(/\s+/)
-            .filter((t) => t.length > 0)
-            .map((t) => `"${t.replace(/"/g, '""')}"`)
-            .join(" ");
-    }
-    async searchMemories(sessionName, query, limit = 10) {
-        const store = await this.getStore(sessionName);
-        const safeQuery = this.sanitizeFts5Query(query);
-        return await store.searchHybrid(safeQuery, limit);
-    }
-    listMemories(sessionName, limit = 50) {
-        const dbPath = this.dbPathFor(sessionName);
-        if (!existsSync(dbPath))
-            return [];
-        const db = new Database(dbPath);
-        db.pragma("journal_mode = WAL");
-        try {
-            const rows = db.prepare(`SELECT id, content, metadata, created_at FROM memories ORDER BY created_at DESC LIMIT ?`).all(limit);
-            return rows.map((r) => ({
-                id: r.id,
-                content: r.content,
-                metadata: r.metadata ? JSON.parse(r.metadata) : {},
-                createdAt: r.created_at,
-            }));
-        }
-        finally {
-            db.close();
-        }
-    }
-    getMemory(sessionName, memoryId) {
-        const dbPath = this.dbPathFor(sessionName);
-        if (!existsSync(dbPath))
-            return null;
-        const db = new Database(dbPath);
-        db.pragma("journal_mode = WAL");
-        try {
-            const row = db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE id = ?`).get(memoryId);
-            if (!row)
-                return null;
-            return {
-                id: row.id,
-                content: row.content,
-                metadata: row.metadata ? JSON.parse(row.metadata) : {},
-                createdAt: row.created_at,
-            };
-        }
-        finally {
-            db.close();
-        }
-    }
-    deleteMemory(sessionName, memoryId) {
-        const dbPath = this.dbPathFor(sessionName);
-        if (!existsSync(dbPath))
-            return false;
-        const db = new Database(dbPath);
-        db.pragma("journal_mode = WAL");
-        try {
-            const result = db.prepare(`DELETE FROM memories WHERE id = ?`).run(memoryId);
-            return result.changes > 0;
-        }
-        finally {
-            db.close();
-        }
-    }
-    async updateMemory(sessionName, memoryId, content, metadata) {
-        const existing = this.getMemory(sessionName, memoryId);
-        if (!existing)
-            return false;
-        // Delete old and re-add with new content (to get new embedding)
-        this.deleteMemory(sessionName, memoryId);
-        // Close the cached store so it picks up the direct DB changes
-        if (this.stores.has(sessionName)) {
-            this.stores.get(sessionName).close();
-            this.stores.delete(sessionName);
-        }
-        const store = await this.getStore(sessionName);
-        const finalMetadata = metadata ?? existing.metadata;
-        await store.add(content, finalMetadata);
-        return true;
-    }
-    getStats(sessionName) {
-        const dbPath = this.dbPathFor(sessionName);
-        if (!existsSync(dbPath))
-            return { total: 0 };
-        const db = new Database(dbPath);
-        db.pragma("journal_mode = WAL");
-        try {
-            const row = db.prepare(`SELECT COUNT(*) as total FROM memories`).get();
-            return { total: row.total };
-        }
-        finally {
-            db.close();
-        }
-    }
-    /**
-     * Warm up the embedding model and verify it loads correctly.
-     * Uses a temporary DB so no real session data is affected.
-     * Throws if the model is corrupt or fails to produce embeddings.
-     */
-    async warmup() {
-        const testDbPath = join(this.basePath, "_warmup_test.db");
-        const cacheDir = join(this.basePath, ".model-cache");
-        const store = await createAgentMemory({
-            dbPath: testDbPath,
-            cacheDir,
-            dtype: "q4",
-        });
-        try {
-            // Force an embedding by adding and searching
-            await store.add("warmup test memory");
-            const results = await store.searchHybrid("warmup test", 1);
-            if (results.length === 0) {
-                throw new Error("Embedding model warmup: search returned no results");
-            }
-        }
-        finally {
-            store.close();
-            // Clean up the temp DB files
-            try {
-                const { unlinkSync } = await import("fs");
-                unlinkSync(testDbPath);
-                // SQLite WAL/SHM files
-                try {
-                    unlinkSync(testDbPath + "-wal");
-                }
-                catch { /* may not exist */ }
-                try {
-                    unlinkSync(testDbPath + "-shm");
-                }
-                catch { /* may not exist */ }
-            }
-            catch { /* ignore cleanup errors */ }
-        }
-    }
-    closeAll() {
-        for (const [, store] of this.stores) {
-            try {
-                store.close();
-            }
-            catch { /* ignore */ }
-        }
-        this.stores.clear();
-    }
-}