agent-office 0.0.3 → 0.0.6

package/dist/server/index.js

@@ -10,13 +10,13 @@ function authMiddleware(password) {
         next();
     };
 }
-export function createApp(sql, opencode, password, serverUrl, cronScheduler) {
+export function createApp(sql, opencode, password, serverUrl, cronScheduler, memoryManager) {
     const app = express();
     app.use(express.json());
     // Worker routes are unauthenticated — mounted before auth middleware
-    app.use("/", createWorkerRouter(sql, opencode, serverUrl));
+    app.use("/", createWorkerRouter(sql, opencode, serverUrl, memoryManager));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler));
+    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler, memoryManager));
     return app;
 }

package/dist/server/memory.d.ts

@@ -0,0 +1,64 @@
+import { createAgentMemory, type MemoryEntry } from "fastmemory";
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
+type MemoryStore = Awaited<ReturnType<typeof createAgentMemory>>;
+/**
+ * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Each session gets its own .db file under <memoryPath>/<sessionName>.db
+ */
+export declare class MemoryManager {
+    private basePath;
+    private stores;
+    constructor(memoryPath: string);
+    private dbPathFor;
+    getStore(sessionName: string): Promise<MemoryStore>;
+    /**
+     * Add a memory for a session
+     */
+    addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    /**
+     * 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.
+     */
+    private sanitizeFts5Query;
+    /**
+     * Search memories using hybrid search (BM25 + vector + RRF)
+     */
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * List all memories for a session (direct SQLite access since fastmemory has no list method)
+     */
+    listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    /**
+     * Get a single memory by ID
+     */
+    getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    /**
+     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
+     */
+    deleteMemory(sessionName: string, memoryId: string): boolean;
+    /**
+     * Update a memory's content (direct SQLite, re-embeds via delete+add)
+     */
+    updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Get stats for a session's memory store
+     */
+    getStats(sessionName: string): {
+        total: number;
+    };
+    /**
+     * 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.
+     */
+    warmup(): Promise<void>;
+    closeAll(): void;
+}
+export {};

package/dist/server/memory.js

@@ -0,0 +1,214 @@
+import { createAgentMemory } from "fastmemory";
+import { mkdirSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import Database from "better-sqlite3";
+/**
+ * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Each session gets its own .db file under <memoryPath>/<sessionName>.db
+ */
+export class MemoryManager {
+    basePath;
+    stores = new Map();
+    constructor(memoryPath) {
+        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;
+    }
+    /**
+     * Add a memory for a session
+     */
+    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(" ");
+    }
+    /**
+     * Search memories using hybrid search (BM25 + vector + RRF)
+     */
+    async searchMemories(sessionName, query, limit = 10) {
+        const store = await this.getStore(sessionName);
+        const safeQuery = this.sanitizeFts5Query(query);
+        return await store.searchHybrid(safeQuery, limit);
+    }
+    /**
+     * List all memories for a session (direct SQLite access since fastmemory has no list method)
+     */
+    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();
+        }
+    }
+    /**
+     * Get a single memory by ID
+     */
+    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();
+        }
+    }
+    /**
+     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
+     */
+    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();
+        }
+    }
+    /**
+     * Update a memory's content (direct SQLite, re-embeds via delete+add)
+     */
+    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);
+        // Re-add with new content but preserve metadata if not provided
+        const finalMetadata = metadata ?? existing.metadata;
+        await store.add(content, finalMetadata);
+        return true;
+    }
+    /**
+     * Get stats for a session's memory store
+     */
+    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
+            const id = 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();
+    }
+}

package/dist/server/routes.d.ts

@@ -2,5 +2,6 @@ import { Router } from "express";
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
 import { CronScheduler } from "./cron.js";
-export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler): Router;
-export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string): Router;
+import type { MemoryManager } from "./memory.js";
+export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
+export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, memoryManager: MemoryManager): Router;