agent-office 0.3.0 → 0.3.1

package/dist/cli.js

@@ -16,6 +16,7 @@ program
     .option("--memory-path <path>", "Directory for memory storage (default: ./.memory)", "./.memory")
     .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
     .option("--opencode-url <url>", "URL of the OpenCode server (default: http://127.0.0.1:4096)", process.env.OPENCODE_URL ?? "http://127.0.0.1:4096")
+    .option("--simple-memory", "Use lightweight SQLite+BM25 memory instead of the default fastmemory (no embeddings, no model download)")
     .action(async (options) => {
     const { serve } = await import("./commands/serve.js");
     await serve(options);

package/dist/commands/serve.d.ts

@@ -6,6 +6,7 @@ interface ServeOptions {
     memoryPath: string;
     password?: string;
     opencodeUrl: string;
+    simpleMemory?: boolean;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/serve.js

@@ -3,7 +3,7 @@ import { runMigrations } from "../db/migrate.js";
 import { OpenCodeCodingServer } from "../lib/opencode-coding-server.js";
 import { createApp } from "../server/index.js";
 import { CronScheduler } from "../server/cron.js";
-import { MemoryManager } from "../server/memory.js";
+import { AgentOfficeFastMemory, AgentOfficeSimpleMemory } from "../server/memory.js";
 export async function serve(options) {
     const password = options.password;
     if (!password) {
@@ -44,20 +44,28 @@ export async function serve(options) {
     const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
     console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
     const serverUrl = `http://${options.host}:${port}`;
-    // Create memory manager and verify embedding model
-    const memoryManager = new MemoryManager(options.memoryPath);
-    console.log("Warming up embedding model...");
-    try {
+    // Create memory manager
+    let memoryManager;
+    if (options.simpleMemory) {
+        console.log("Using simple SQLite+BM25 memory backend.");
+        memoryManager = new AgentOfficeSimpleMemory(options.memoryPath);
         await memoryManager.warmup();
-        console.log("Embedding model ready.");
     }
-    catch (err) {
-        console.error("Embedding model failed to load:", err);
-        console.error("Try deleting the model cache and restarting:");
-        console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
-        memoryManager.closeAll();
-        await storage.close();
-        process.exit(1);
+    else {
+        memoryManager = new AgentOfficeFastMemory(options.memoryPath);
+        console.log("Warming up embedding model...");
+        try {
+            await memoryManager.warmup();
+            console.log("Embedding model ready.");
+        }
+        catch (err) {
+            console.error("Embedding model failed to load:", err);
+            console.error("Try deleting the model cache and restarting:");
+            console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
+            memoryManager.closeAll();
+            await storage.close();
+            process.exit(1);
+        }
     }
     // Create cron scheduler
     const cronScheduler = new CronScheduler();

package/dist/server/index.d.ts

@@ -1,5 +1,5 @@
 import type { AgentOfficeStorage } from "../db/index.js";
 import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
-import type { MemoryManager } from "./memory.js";
-export declare function createApp(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: MemoryManager): import("express-serve-static-core").Express;
+import type { AgentOfficeMemory } from "./memory.js";
+export declare function createApp(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: AgentOfficeMemory): import("express-serve-static-core").Express;

package/dist/server/memory.d.ts

@@ -1,24 +1,66 @@
-import { createAgentMemory, type MemoryEntry } from "fastmemory";
+import { type MemoryEntry } from "fastmemory";
 export interface MemoryRecord {
     id: string;
     content: string;
     metadata: Record<string, unknown>;
     createdAt: string;
 }
-type MemoryStore = Awaited<ReturnType<typeof createAgentMemory>>;
+export type AgentOfficeMemorySearchResult = MemoryEntry;
 /**
- * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Abstract base class for agent memory backends.
+ * Consumers should depend on this type rather than any concrete implementation.
+ */
+export declare abstract class AgentOfficeMemory {
+    abstract addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    abstract searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
+    abstract listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    abstract getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    abstract deleteMemory(sessionName: string, memoryId: string): boolean;
+    abstract updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    abstract getStats(sessionName: string): {
+        total: number;
+    };
+    abstract warmup(): Promise<void>;
+    abstract closeAll(): void;
+}
+/**
+ * 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 declare class AgentOfficeSimpleMemory extends AgentOfficeMemory {
+    private basePath;
+    private db;
+    constructor(memoryPath: string);
+    private _migrate;
+    private newId;
+    private sanitizeFts5Query;
+    addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
+    listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    deleteMemory(sessionName: string, memoryId: string): boolean;
+    updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    getStats(sessionName: string): {
+        total: number;
+    };
+    warmup(): Promise<void>;
+    closeAll(): void;
+}
+/**
+ * Concrete AgentOfficeMemory implementation backed by fastmemory (SQLite + embeddings).
  * Each session gets its own .db file under <memoryPath>/<sessionName>.db
  */
-export declare class MemoryManager {
+export declare class AgentOfficeFastMemory extends AgentOfficeMemory {
     private basePath;
     private stores;
     constructor(memoryPath: string);
     private dbPathFor;
-    getStore(sessionName: string): Promise<MemoryStore>;
-    /**
-     * Add a memory for a session
-     */
+    private getStore;
     addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
     /**
      * Sanitize a query string for FTS5 MATCH syntax.
@@ -27,29 +69,11 @@ export declare class MemoryManager {
      * 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)
-     */
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<AgentOfficeMemorySearchResult[]>;
     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;
     };
@@ -61,4 +85,3 @@ export declare class MemoryManager {
     warmup(): Promise<void>;
     closeAll(): void;
 }
-export {};

package/dist/server/memory.js

@@ -3,13 +3,169 @@ 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).
+ * 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 MemoryManager {
+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 });
@@ -34,9 +190,6 @@ export class MemoryManager {
         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);
@@ -54,17 +207,11 @@ export class MemoryManager {
             .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))
@@ -84,9 +231,6 @@ export class MemoryManager {
             db.close();
         }
     }
-    /**
-     * Get a single memory by ID
-     */
     getMemory(sessionName, memoryId) {
         const dbPath = this.dbPathFor(sessionName);
         if (!existsSync(dbPath))
@@ -108,9 +252,6 @@ export class MemoryManager {
             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))
@@ -125,9 +266,6 @@ export class MemoryManager {
             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)
@@ -140,14 +278,10 @@ export class MemoryManager {
             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))
@@ -177,7 +311,7 @@ export class MemoryManager {
         });
         try {
             // Force an embedding by adding and searching
-            const id = await store.add("warmup test memory");
+            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");

package/dist/server/routes.d.ts

@@ -2,7 +2,7 @@ import { Router } from "express";
 import type { AgentOfficeStorage } from "../db/index.js";
 import type { AgenticCodingServer } from "../lib/agentic-coding-server.js";
 import { CronScheduler } from "./cron.js";
-import type { MemoryManager } from "./memory.js";
+import type { AgentOfficeMemory } from "./memory.js";
 /**
  * Build the persistent system-prompt briefing for a worker session.
  * This is injected as the `system` field on every `promptAsync` call so the
@@ -10,5 +10,5 @@ import type { MemoryManager } from "./memory.js";
  * without consuming a user-message turn.
  */
 export declare function generateSystemPrompt(name: string, status: string | null, humanName: string, humanDescription: string, token: string): string;
-export declare function createRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
-export declare function createWorkerRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: MemoryManager): Router;
+export declare function createRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, scheduler: CronScheduler, memoryManager: AgentOfficeMemory): Router;
+export declare function createWorkerRouter(storage: AgentOfficeStorage, agenticCodingServer: AgenticCodingServer, serverUrl: string, memoryManager: AgentOfficeMemory): Router;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",