agent-office 0.3.1 → 0.4.0

package/dist/server/routes.js

@@ -4,17 +4,12 @@ const MAIL_INJECTION_BLURB = [
     ``,
     `---`,
     `You have a new message. Please review the injected message above and respond accordingly.`,
-    `IMPORTANT: When reading or responding, note that dollar signs ($) and other special`,
-    `characters may be interpreted as markdown. The sender may have included them but they`,
-    `could appear differently in your session view. Interpret context accordingly.`,
     ``,
     `When responding to the sender:`,
     `- Use the \`agent-office worker send-message\` tool so they can see your reply`,
     `- Avoid excessive length - keep responses concise`,
-    `- Use markdown front-matter with a "choices" array if offering options`,
-    ``,
-    `Tip: For currency or prices, use code blocks. Example: put numbers in single or`,
-    `double quotes to preserve formatting characters like dollar signs.`,
+    `- Feel free to use markdown formatting`,
+    `- IMPORTANT: Remember when using bash commands certain characters (like dollar signs) may need to be escaped or wrapped in quotes`,
 ].join("\n");
 /**
  * Build the persistent system-prompt briefing for a worker session.
@@ -78,23 +73,22 @@ export function generateSystemPrompt(name, status, humanName, humanDescription,
         `   agent-office worker cron \\`,
         `     ${token}`,
         ``,
-        ` Store a memory (persistent across sessions)`,
-        `   agent-office worker memory add \\`,
-        `     --content "your memory here" \\`,
-        `     ${token}`,
-        ``,
-        ` Search your memories`,
-        `   agent-office worker memory search \\`,
-        `     --query "your search" \\`,
+        ` Create a cron job (scheduled task)`,
+        `   agent-office worker cron create \\`,
+        `     --name <job-name> \\`,
+        `     --schedule "<cron-expression>" \\`,
+        `     --message "<action-to-perform>" \\`,
+        `     --respond-to "<who-to-respond-to-when-done>" \\`,
         `     ${token}`,
         ``,
-        ` List all your memories`,
-        `   agent-office worker memory list \\`,
-        `     ${token}`,
+        `   Example: Daily standup reminder at 9am`,
+        `     --schedule "0 9 * * *" \\`,
+        `     --message "Prepare your standup update" \\`,
+        `     --respond-to "${humanName} in the standup channel"`,
         ``,
-        ` Forget a memory`,
-        `   agent-office worker memory forget \\`,
-        `     ${token} <memory-id>`,
+        `   The final injected message will be formatted as:`,
+        `     Action: <message>`,
+        `     Who to respond to when done: <respond-to>`,
         ``,
         `════════════════════════════════════════════════════════`,
         ` IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
@@ -141,7 +135,7 @@ async function loadHumanConfig(storage) {
         humanDescription: humanDescription ?? "",
     };
 }
-export function createRouter(storage, agenticCodingServer, serverUrl, scheduler, memoryManager) {
+export function createRouter(storage, agenticCodingServer, serverUrl, scheduler) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
@@ -192,6 +186,27 @@ export function createRouter(storage, agenticCodingServer, serverUrl, scheduler,
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    router.get("/coworkers", async (_req, res) => {
+        try {
+            const sessions = await storage.listSessions();
+            const humanName = await storage.getConfig('human_name') ?? "Human";
+            const unreadCounts = await storage.countUnreadBySender(humanName);
+            const coworkers = [
+                { name: humanName, status: null, isHuman: true, unreadMessages: 0 },
+                ...sessions.map(s => ({
+                    name: s.name,
+                    status: s.status,
+                    isHuman: false,
+                    unreadMessages: unreadCounts.get(s.name) ?? 0
+                }))
+            ];
+            res.json(coworkers);
+        }
+        catch (err) {
+            console.error("GET /coworkers error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     router.post("/sessions", async (req, res) => {
         const { name, agent: agentArg } = req.body;
         if (!name || typeof name !== "string" || !name.trim()) {
@@ -441,7 +456,7 @@ export function createRouter(storage, agenticCodingServer, serverUrl, scheduler,
                 rows = await storage.listMessagesFromSender(name);
             }
             else {
-                rows = await storage.listMessagesForRecipient(name, unread_only === "true");
+                rows = await storage.listMessagesForRecipient(name, unread_only === "true" ? { unread: true } : undefined);
             }
             res.json(rows);
         }
@@ -524,6 +539,39 @@ export function createRouter(storage, agenticCodingServer, serverUrl, scheduler,
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Human Notification API ─────────────────────────────────────────────────
+    router.get("/human/unread-old", async (req, res) => {
+        try {
+            const hoursStr = req.query.hours ?? "";
+            const hours = hoursStr !== "" ? parseFloat(hoursStr) : 1;
+            const humanName = (await storage.getConfig("human_name")) ?? "Human";
+            const msgs = await storage.listMessagesForRecipient(humanName, {
+                unread: true,
+                olderThanHours: hours,
+                notified: false,
+            });
+            res.json(msgs);
+        }
+        catch (err) {
+            console.error("GET /human/unread-old error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/human/mark-notified", async (req, res) => {
+        try {
+            const ids = req.body.ids;
+            if (!Array.isArray(ids) || !ids.every((id) => typeof id === "number")) {
+                res.status(400).json({ error: "ids must be an array of numbers" });
+                return;
+            }
+            await storage.markMessagesAsNotified(ids);
+            res.json({ success: true, count: ids.length });
+        }
+        catch (err) {
+            console.error("POST /human/mark-notified error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     // ── Cron Jobs Endpoints ────────────────────────────────────────────────────
     router.get("/crons", async (req, res) => {
         try {
@@ -739,135 +787,9 @@ export function createRouter(storage, agenticCodingServer, serverUrl, scheduler,
             res.status(500).json({ error: "Internal server error" });
         }
     });
-    // ── Memory Endpoints (authenticated, for manage TUI) ───────────────────────
-    router.get("/sessions/:name/memories", async (req, res) => {
-        const { name } = req.params;
-        const limit = Math.min(parseInt(req.query.limit ?? "50", 10), 200);
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const memories = memoryManager.listMemories(name, limit);
-            const stats = memoryManager.getStats(name);
-            res.json({ memories, total: stats.total });
-        }
-        catch (err) {
-            console.error("GET /sessions/:name/memories error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.post("/sessions/:name/memories", async (req, res) => {
-        const { name } = req.params;
-        const { content, metadata } = req.body;
-        if (!content || typeof content !== "string" || !content.trim()) {
-            res.status(400).json({ error: "content is required" });
-            return;
-        }
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const id = await memoryManager.addMemory(name, content.trim(), metadata ?? {});
-            res.status(201).json({ ok: true, id });
-        }
-        catch (err) {
-            console.error("POST /sessions/:name/memories error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.get("/sessions/:name/memories/:memoryId", async (req, res) => {
-        const { name, memoryId } = req.params;
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const memory = memoryManager.getMemory(name, memoryId);
-            if (!memory) {
-                res.status(404).json({ error: "Memory not found" });
-                return;
-            }
-            res.json(memory);
-        }
-        catch (err) {
-            console.error("GET /sessions/:name/memories/:memoryId error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.put("/sessions/:name/memories/:memoryId", async (req, res) => {
-        const { name, memoryId } = req.params;
-        const { content, metadata } = req.body;
-        if (!content || typeof content !== "string" || !content.trim()) {
-            res.status(400).json({ error: "content is required" });
-            return;
-        }
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const updated = await memoryManager.updateMemory(name, memoryId, content.trim(), metadata);
-            if (!updated) {
-                res.status(404).json({ error: "Memory not found" });
-                return;
-            }
-            res.json({ ok: true });
-        }
-        catch (err) {
-            console.error("PUT /sessions/:name/memories/:memoryId error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.delete("/sessions/:name/memories/:memoryId", async (req, res) => {
-        const { name, memoryId } = req.params;
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const deleted = memoryManager.deleteMemory(name, memoryId);
-            if (!deleted) {
-                res.status(404).json({ error: "Memory not found" });
-                return;
-            }
-            res.json({ deleted: true, id: memoryId });
-        }
-        catch (err) {
-            console.error("DELETE /sessions/:name/memories/:memoryId error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.post("/sessions/:name/memories/search", async (req, res) => {
-        const { name } = req.params;
-        const { query, limit } = req.body;
-        if (!query || typeof query !== "string" || !query.trim()) {
-            res.status(400).json({ error: "query is required" });
-            return;
-        }
-        const sessionId = await storage.getSessionIdByName(name);
-        if (!sessionId) {
-            res.status(404).json({ error: `Session "${name}" not found` });
-            return;
-        }
-        try {
-            const results = await memoryManager.searchMemories(name, query.trim(), Math.min(limit ?? 10, 50));
-            res.json(results);
-        }
-        catch (err) {
-            console.error("POST /sessions/:name/memories/search error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
     return router;
 }
-export function createWorkerRouter(storage, agenticCodingServer, serverUrl, memoryManager) {
+export function createWorkerRouter(storage, agenticCodingServer, serverUrl) {
     const router = Router();
     router.get("/worker/list-coworkers", async (req, res) => {
         const { code } = req.query;
@@ -1255,107 +1177,5 @@ export function createWorkerRouter(storage, agenticCodingServer, serverUrl, memo
             res.status(500).json({ error: "Internal server error" });
         }
     });
-    // ── Worker Memory Endpoints (authenticated via agent_code in query) ────────
-    router.post("/worker/memory/add", async (req, res) => {
-        const { code } = req.query;
-        const { content, metadata } = req.body;
-        if (!code || typeof code !== "string") {
-            res.status(400).json({ error: "code query parameter is required" });
-            return;
-        }
-        if (!content || typeof content !== "string" || !content.trim()) {
-            res.status(400).json({ error: "content is required" });
-            return;
-        }
-        const session = await storage.getSessionByAgentCode(code);
-        if (!session) {
-            res.status(401).json({ error: "Invalid agent code" });
-            return;
-        }
-        const sessionName = session.name;
-        try {
-            const id = await memoryManager.addMemory(sessionName, content.trim(), metadata ?? {});
-            res.status(201).json({ ok: true, id });
-        }
-        catch (err) {
-            console.error("POST /worker/memory/add error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.post("/worker/memory/search", async (req, res) => {
-        const { code } = req.query;
-        const { query, limit } = req.body;
-        if (!code || typeof code !== "string") {
-            res.status(400).json({ error: "code query parameter is required" });
-            return;
-        }
-        if (!query || typeof query !== "string" || !query.trim()) {
-            res.status(400).json({ error: "query is required" });
-            return;
-        }
-        const session = await storage.getSessionByAgentCode(code);
-        if (!session) {
-            res.status(401).json({ error: "Invalid agent code" });
-            return;
-        }
-        const sessionName = session.name;
-        try {
-            const results = await memoryManager.searchMemories(sessionName, query.trim(), Math.min(limit ?? 10, 50));
-            res.json(results);
-        }
-        catch (err) {
-            console.error("POST /worker/memory/search error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.get("/worker/memory/list", async (req, res) => {
-        const { code, limit: limitStr } = req.query;
-        if (!code || typeof code !== "string") {
-            res.status(400).json({ error: "code query parameter is required" });
-            return;
-        }
-        const session = await storage.getSessionByAgentCode(code);
-        if (!session) {
-            res.status(401).json({ error: "Invalid agent code" });
-            return;
-        }
-        const sessionName = session.name;
-        const limit = Math.min(parseInt(limitStr ?? "50", 10), 200);
-        try {
-            const memories = memoryManager.listMemories(sessionName, limit);
-            const stats = memoryManager.getStats(sessionName);
-            res.json({ memories, total: stats.total });
-        }
-        catch (err) {
-            console.error("GET /worker/memory/list error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
-    router.delete("/worker/memory/:memoryId", async (req, res) => {
-        const { code } = req.query;
-        const { memoryId } = req.params;
-        if (!code || typeof code !== "string") {
-            res.status(400).json({ error: "code query parameter is required" });
-            return;
-        }
-        const session = await storage.getSessionByAgentCode(code);
-        if (!session) {
-            res.status(401).json({ error: "Invalid agent code" });
-            return;
-        }
-        const sessionName = session.name;
-        try {
-            const deleted = memoryManager.deleteMemory(sessionName, memoryId);
-            if (!deleted) {
-                res.status(404).json({ error: "Memory not found" });
-                return;
-            }
-            res.json({ deleted: true, id: memoryId });
-        }
-        catch (err) {
-            console.error("DELETE /worker/memory/:memoryId error:", err);
-            res.status(500).json({ error: "Internal server error" });
-        }
-    });
     return router;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "An office for your AI agents",
   "type": "module",
   "license": "MIT",
@@ -40,17 +40,17 @@
     "croner": "^10.0.1",
     "dotenv": "^17.0.0",
     "express": "^5.0.0",
-    "fastmemory": "^0.1.5",
     "ink": "^6.0.0",
     "postgres": "^3.4.0",
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "resend": "^6.9.2"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.0",
     "@types/node": "^22.0.0",
     "@types/react": "^19.0.0",
-    "tsx": "^4.0.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.0.0"
   }
 }

package/dist/server/memory.d.ts

@@ -1,87 +0,0 @@
-import { type MemoryEntry } from "fastmemory";
-export interface MemoryRecord {
-    id: string;
-    content: string;
-    metadata: Record<string, unknown>;
-    createdAt: string;
-}
-export type AgentOfficeMemorySearchResult = MemoryEntry;
-/**
- * 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 AgentOfficeFastMemory extends AgentOfficeMemory {
-    private basePath;
-    private stores;
-    constructor(memoryPath: string);
-    private dbPathFor;
-    private getStore;
-    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;
-    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;
-    };
-    /**
-     * 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;
-}