zubo 0.1.21 → 0.1.23

package/src/tools/builtin/todos.ts

@@ -0,0 +1,270 @@
+import { registerTool } from "../registry";
+import { getDb } from "../../db/connection";
+
+function parseDate(input: string): string {
+  const now = new Date();
+  const lower = input.toLowerCase().trim();
+
+  if (lower === "today") return now.toISOString().split("T")[0];
+
+  if (lower === "tomorrow") {
+    now.setDate(now.getDate() + 1);
+    return now.toISOString().split("T")[0];
+  }
+
+  if (lower === "next week") {
+    now.setDate(now.getDate() + 7);
+    return now.toISOString().split("T")[0];
+  }
+
+  const days = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+  ];
+
+  for (let i = 0; i < days.length; i++) {
+    if (lower.includes(days[i])) {
+      const current = now.getDay();
+      let diff = i - current;
+      if (diff <= 0) diff += 7;
+      if (lower.includes("next")) diff += 7;
+      now.setDate(now.getDate() + diff);
+      return now.toISOString().split("T")[0];
+    }
+  }
+
+  const parsed = new Date(input);
+  if (!isNaN(parsed.getTime())) return parsed.toISOString().split("T")[0];
+
+  return input;
+}
+
+function formatDueDate(dueDate: string | null): string {
+  if (!dueDate) return "";
+
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const due = new Date(dueDate + "T00:00:00");
+  const diffDays = Math.round(
+    (due.getTime() - today.getTime()) / (1000 * 60 * 60 * 24)
+  );
+
+  if (diffDays < 0) return `overdue by ${Math.abs(diffDays)}d`;
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "tomorrow";
+  if (diffDays <= 7) return `in ${diffDays} days`;
+  return dueDate;
+}
+
+interface TodoRow {
+  id: number;
+  title: string;
+  description: string | null;
+  priority: string;
+  status: string;
+  due_date: string | null;
+  tags: string;
+  created_at: string;
+  completed_at: string | null;
+}
+
+export function registerTodosTool() {
+  registerTool({
+    definition: {
+      name: "todos",
+      description:
+        "Manage the user's to-do list. Add, list, complete, remove, or update tasks with priorities, due dates, and tags.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["add", "list", "complete", "remove", "update"],
+            description: "The action to perform on the todo list.",
+          },
+          title: {
+            type: "string",
+            description: "Title of the todo item (for add).",
+          },
+          description: {
+            type: "string",
+            description: "Optional description (for add/update).",
+          },
+          priority: {
+            type: "string",
+            enum: ["low", "medium", "high", "urgent"],
+            description: "Priority level (for add/update).",
+          },
+          due_date: {
+            type: "string",
+            description:
+              'Due date — natural language like "tomorrow", "next friday", or an ISO date (for add/update).',
+          },
+          tags: {
+            type: "string",
+            description:
+              "Comma-separated tags (for add/update). Example: 'work, urgent'.",
+          },
+          id: {
+            type: "number",
+            description: "Todo ID (for complete/remove/update).",
+          },
+          filter: {
+            type: "string",
+            description:
+              'Filter for list action: "all", "pending", "done", "urgent", "overdue". Defaults to "pending".',
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const db = getDb();
+      const action = input.action as string;
+
+      if (action === "add") {
+        const title = input.title as string;
+        if (!title) return "Error: title is required to add a todo.";
+
+        const priority = (input.priority as string) || "medium";
+        const description = (input.description as string) || null;
+        const tags = input.tags
+          ? JSON.stringify(
+              (input.tags as string).split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+            )
+          : "[]";
+        const dueDate = input.due_date
+          ? parseDate(input.due_date as string)
+          : null;
+
+        const result = db
+          .prepare(
+            "INSERT INTO todos (title, description, priority, due_date, tags) VALUES (?, ?, ?, ?, ?)"
+          )
+          .run(title, description, priority, dueDate, tags);
+
+        let msg = `Added: #${result.lastInsertRowid} ${title} [${priority}]`;
+        if (dueDate) msg += ` due: ${formatDueDate(dueDate)}`;
+        return msg;
+      }
+
+      if (action === "list") {
+        const filter = (input.filter as string) || "pending";
+
+        let query = "SELECT * FROM todos";
+        const params: string[] = [];
+
+        if (filter === "pending") {
+          query += " WHERE status = 'pending'";
+        } else if (filter === "done") {
+          query += " WHERE status = 'done'";
+        } else if (filter === "urgent") {
+          query += " WHERE priority = 'urgent' AND status = 'pending'";
+        } else if (filter === "overdue") {
+          query +=
+            " WHERE due_date < date('now') AND status = 'pending' AND due_date IS NOT NULL";
+        }
+        // "all" has no WHERE clause
+
+        query +=
+          " ORDER BY CASE priority WHEN 'urgent' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END, due_date ASC NULLS LAST";
+
+        const rows = db.prepare(query).all(...params) as TodoRow[];
+
+        if (rows.length === 0) return `No ${filter} todos found.`;
+
+        const lines = rows.map((row) => {
+          const check = row.status === "done" ? "☑" : "☐";
+          let line = `${check} #${row.id} ${row.title} [${row.priority}]`;
+          if (row.due_date) line += ` due: ${formatDueDate(row.due_date)}`;
+          if (row.tags && row.tags !== "[]") {
+            const tagList = JSON.parse(row.tags) as string[];
+            if (tagList.length > 0) line += ` {${tagList.join(", ")}}`;
+          }
+          if (row.status === "done") line += " [done]";
+          return line;
+        });
+
+        return `Todos (${filter} — ${rows.length} items):\n${lines.join("\n")}`;
+      }
+
+      if (action === "complete") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to complete a todo.";
+
+        const changes = db
+          .prepare(
+            "UPDATE todos SET status = 'done', completed_at = datetime('now') WHERE id = ?"
+          )
+          .run(id);
+
+        if (changes.changes === 0) return `No todo found with id #${id}.`;
+        return `Completed todo #${id}.`;
+      }
+
+      if (action === "remove") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to remove a todo.";
+
+        const changes = db
+          .prepare("DELETE FROM todos WHERE id = ?")
+          .run(id);
+
+        if (changes.changes === 0) return `No todo found with id #${id}.`;
+        return `Removed todo #${id}.`;
+      }
+
+      if (action === "update") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to update a todo.";
+
+        const updates: string[] = [];
+        const values: (string | null)[] = [];
+
+        if (input.title) {
+          updates.push("title = ?");
+          values.push(input.title as string);
+        }
+        if (input.description !== undefined) {
+          updates.push("description = ?");
+          values.push((input.description as string) || null);
+        }
+        if (input.priority) {
+          updates.push("priority = ?");
+          values.push(input.priority as string);
+        }
+        if (input.due_date) {
+          updates.push("due_date = ?");
+          values.push(parseDate(input.due_date as string));
+        }
+        if (input.tags) {
+          updates.push("tags = ?");
+          values.push(
+            JSON.stringify(
+              (input.tags as string).split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+            )
+          );
+        }
+
+        if (updates.length === 0)
+          return "Error: provide at least one field to update.";
+
+        values.push(String(id));
+
+        const changes = db
+          .prepare(`UPDATE todos SET ${updates.join(", ")} WHERE id = ?`)
+          .run(...values);
+
+        if (changes.changes === 0) return `No todo found with id #${id}.`;
+        return `Updated todo #${id}.`;
+      }
+
+      return `Unknown action: ${action}. Use add, list, complete, remove, or update.`;
+    },
+  });
+}

package/src/tools/builtin/topics.ts

@@ -0,0 +1,166 @@
+import { registerTool } from "../registry";
+import { getDb } from "../../db/connection";
+
+let activeTopic: string | null = null;
+
+export function registerTopicsTool() {
+  registerTool({
+    definition: {
+      name: "topics",
+      description:
+        "Organize conversations into named topics or threads. Each topic scopes the conversation context so you can keep separate discussions organized (e.g. 'work project', 'trip planning'). Use this to create, switch between, list, archive, or check the current topic.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "switch", "list", "archive", "current"],
+            description:
+              "The action to perform: create a new topic, switch to an existing one, list all active topics, archive a topic, or check the current topic.",
+          },
+          name: {
+            type: "string",
+            description:
+              "The topic name (for create, switch, and archive). Examples: 'work project', 'trip planning', 'recipe ideas'.",
+          },
+          description: {
+            type: "string",
+            description: "Optional description of the topic (for create).",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const { action, name, description } = input as {
+        action: string;
+        name?: string;
+        description?: string;
+      };
+      const db = getDb();
+
+      switch (action) {
+        case "create": {
+          if (!name) {
+            return "Error: 'name' is required to create a topic.";
+          }
+          db.prepare(
+            `INSERT INTO conversation_topics (name, description) VALUES (?, ?)`
+          ).run(name, description ?? null);
+          return `Topic '${name}' created. Switch to it with action 'switch'.`;
+        }
+
+        case "switch": {
+          if (!name) {
+            return "Error: 'name' is required to switch topics.";
+          }
+          const existing = db
+            .query<{ name: string }, [string]>(
+              `SELECT name FROM conversation_topics WHERE name = ? AND status = 'active'`
+            )
+            .get(name);
+
+          if (!existing) {
+            db.prepare(
+              `INSERT OR IGNORE INTO conversation_topics (name) VALUES (?)`
+            ).run(name);
+          }
+
+          db.prepare(
+            `UPDATE conversation_topics SET last_message_at = datetime('now') WHERE name = ?`
+          ).run(name);
+          activeTopic = name;
+          return `Switched to topic: ${name}. Your conversation context is now scoped to this topic.`;
+        }
+
+        case "list": {
+          const topics = db
+            .query<
+              {
+                name: string;
+                description: string | null;
+                last_message_at: string;
+              },
+              []
+            >(
+              `SELECT name, description, last_message_at FROM conversation_topics WHERE status = 'active' ORDER BY last_message_at DESC`
+            )
+            .all();
+
+          if (topics.length === 0) {
+            return `No active topics yet. Create one with action 'create'.\n\nCurrent: ${activeTopic ?? "default"}`;
+          }
+
+          const lines = topics.map((t) => {
+            const ago = formatTimeAgo(t.last_message_at);
+            const desc = t.description ? ` — ${t.description}` : "";
+            return `- ${t.name}${desc} (last used: ${ago})`;
+          });
+
+          return `Active topics:\n${lines.join("\n")}\n\nCurrent: ${activeTopic ?? "default"}`;
+        }
+
+        case "archive": {
+          if (!name) {
+            return "Error: 'name' is required to archive a topic.";
+          }
+          const result = db.prepare(
+            `UPDATE conversation_topics SET status = 'archived' WHERE name = ? AND status = 'active'`
+          ).run(name);
+          if (result.changes === 0) {
+            return `No active topic found with name '${name}'.`;
+          }
+          if (activeTopic === name) {
+            activeTopic = null;
+          }
+          return `Topic '${name}' archived. It will no longer appear in your active topics list.`;
+        }
+
+        case "current": {
+          if (!activeTopic) {
+            return "default (no topic selected)";
+          }
+          return activeTopic;
+        }
+
+        default:
+          return `Unknown action: ${action}. Use one of: create, switch, list, archive, current.`;
+      }
+    },
+  });
+}
+
+/** Get the current active topic (used by router to determine session key). */
+export function getActiveTopic(): string | null {
+  return activeTopic;
+}
+
+/** Get the session ID for the current topic. */
+export function getTopicSessionId(): string {
+  if (!activeTopic) return "owner";
+  const safe = activeTopic
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+  return `topic-${safe}`;
+}
+
+function formatTimeAgo(isoDate: string): string {
+  const then = new Date(isoDate + "Z").getTime();
+  const now = Date.now();
+  const diffMs = now - then;
+
+  const minutes = Math.floor(diffMs / 60_000);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+
+  const days = Math.floor(hours / 24);
+  if (days === 1) return "yesterday";
+  if (days < 7) return `${days} days ago`;
+
+  const weeks = Math.floor(days / 7);
+  return `${weeks} week${weeks === 1 ? "" : "s"} ago`;
+}

package/src/tools/mcp-client.ts

@@ -354,6 +354,12 @@ export class McpClient {
 // --- Global MCP management ---
 
 const mcpClients = new Map<string, McpClient>();
+const failedMcpServers: { name: string; error: string }[] = [];
+
+/** Returns list of MCP servers that failed to initialize. */
+export function getFailedMcpServers(): { name: string; error: string }[] {
+  return failedMcpServers;
+}
 
 /**
  * Initialize all configured MCP servers and register their tools.
@@ -361,6 +367,7 @@ const mcpClients = new Map<string, McpClient>();
 export async function initMcpServers(
   configs: McpServerConfig[]
 ): Promise<void> {
+  failedMcpServers.length = 0;
   for (const config of configs) {
     if (config.enabled === false) continue;
 
@@ -372,6 +379,7 @@ export async function initMcpServers(
       mcpClients.set(config.name, client);
     } catch (err: any) {
       logger.error(`Failed to start MCP server "${config.name}"`, { error: err.message });
+      failedMcpServers.push({ name: config.name, error: err.message });
     }
   }
 }

package/src/tools/permissions.ts

@@ -33,6 +33,13 @@ const DEFAULT_PERMISSIONS: Record<string, ToolPermission> = {
   kg_query: "auto",
   kg_update: "auto",
 
+  // Personal features — safe (user-facing data management)
+  todos: "auto",
+  notes: "auto",
+  preferences: "auto",
+  topics: "auto",
+  follow_ups: "auto",
+
   // Built-in skills — safe (read-only or low risk)
   web_search: "auto",
   url_fetch: "auto",

package/tests/agent/session.test.ts

@@ -1,28 +1,29 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, rmSync } from "fs";
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync, appendFileSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
+import { randomBytes } from "crypto";
 
-// Override paths.sessions before importing session module
 import { paths } from "../../src/config/paths";
-
-let tempDir: string;
-
-// Patch the sessions path to a temp directory before each test
-beforeEach(() => {
-  tempDir = mkdtempSync(join(tmpdir(), "orba-session-test-"));
-  (paths as any).sessions = tempDir;
-});
-
-afterEach(() => {
-  rmSync(tempDir, { recursive: true, force: true });
-});
-
-// Import after paths is available (the module reads paths at call time, not import time)
 import { appendMessage, loadSession, sessionExists } from "../../src/agent/session";
 import type { SessionMessage } from "../../src/agent/session";
 
 describe("session management", () => {
+  let tempDir: string;
+  let originalSessionsPath: string;
+  const uid = randomBytes(4).toString("hex");
+
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "orba-session-test-"));
+    originalSessionsPath = (paths as any).sessions;
+    (paths as any).sessions = tempDir;
+  });
+
+  afterAll(() => {
+    (paths as any).sessions = originalSessionsPath;
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
   test("appendMessage creates a session file and appends a message", () => {
     const msg: SessionMessage = {
       role: "user",
@@ -30,22 +31,22 @@ describe("session management", () => {
       timestamp: new Date().toISOString(),
     };
 
-    appendMessage("test-session", msg);
-    expect(sessionExists("test-session")).toBe(true);
+    appendMessage(`test-session-${uid}`, msg);
+    expect(sessionExists(`test-session-${uid}`)).toBe(true);
   });
 
   test("loadSession returns messages in order", () => {
-    const messages: SessionMessage[] = [
-      { role: "user", content: "First", timestamp: "2025-01-01T00:00:00Z" },
-      { role: "assistant", content: "Second", timestamp: "2025-01-01T00:00:01Z" },
-      { role: "user", content: "Third", timestamp: "2025-01-01T00:00:02Z" },
-    ];
+    const id = `ordered-${uid}`;
+    const sessionFile = join(tempDir, `${id}.jsonl`);
 
-    for (const msg of messages) {
-      appendMessage("ordered-session", msg);
-    }
+    const content = [
+      JSON.stringify({ role: "user", content: "First", timestamp: "2025-01-01T00:00:00Z" }),
+      JSON.stringify({ role: "assistant", content: "Second", timestamp: "2025-01-01T00:00:01Z" }),
+      JSON.stringify({ role: "user", content: "Third", timestamp: "2025-01-01T00:00:02Z" }),
+    ].join("\n") + "\n";
+    writeFileSync(sessionFile, content);
 
-    const loaded = loadSession("ordered-session");
+    const loaded = loadSession(id);
     expect(loaded).toHaveLength(3);
     expect(loaded[0].content).toBe("First");
     expect(loaded[1].content).toBe("Second");
@@ -53,24 +54,23 @@ describe("session management", () => {
   });
 
   test("loadSession respects the limit parameter", () => {
-    for (let i = 0; i < 10; i++) {
-      appendMessage("limited-session", {
-        role: "user",
-        content: `Message ${i}`,
-        timestamp: new Date().toISOString(),
-      });
-    }
+    const id = `limited-${uid}`;
+    const sessionFile = join(tempDir, `${id}.jsonl`);
+
+    const lines = Array.from({ length: 10 }, (_, i) =>
+      JSON.stringify({ role: "user", content: `Message ${i}`, timestamp: new Date().toISOString() })
+    ).join("\n") + "\n";
+    writeFileSync(sessionFile, lines);
 
-    const loaded = loadSession("limited-session", 3);
+    const loaded = loadSession(id, 3);
     expect(loaded).toHaveLength(3);
-    // Should return the last 3 messages
     expect(loaded[0].content).toBe("Message 7");
     expect(loaded[1].content).toBe("Message 8");
     expect(loaded[2].content).toBe("Message 9");
   });
 
   test("loadSession returns empty array for nonexistent session", () => {
-    const loaded = loadSession("does-not-exist");
+    const loaded = loadSession(`nonexistent-${uid}`);
     expect(loaded).toEqual([]);
   });
 
@@ -95,14 +95,12 @@ describe("session management", () => {
   });
 
   test("session ID allows colons for channel:userId format", () => {
-    const msg: SessionMessage = {
-      role: "user",
-      content: "Hello from channel",
-      timestamp: new Date().toISOString(),
-    };
+    const id = `discord:user-${uid}`;
+    const sessionFile = join(tempDir, `${id}.jsonl`);
+    const msg = { role: "user", content: "Hello from channel", timestamp: new Date().toISOString() };
+    writeFileSync(sessionFile, JSON.stringify(msg) + "\n");
 
-    appendMessage("discord:user123", msg);
-    const loaded = loadSession("discord:user123");
+    const loaded = loadSession(id);
     expect(loaded).toHaveLength(1);
     expect(loaded[0].content).toBe("Hello from channel");
   });