zubo 0.1.21 → 0.1.23

package/src/tools/builtin/follow-ups.ts

@@ -0,0 +1,189 @@
+import { registerTool } from "../registry";
+import { addCronJob, removeCronJob } from "../../scheduler/cron";
+import { parseNaturalSchedule } from "../../scheduler/natural-cron";
+import type { MessageRouter } from "../../channels/router";
+import type { ZuboConfig } from "../../config/schema";
+import type { LlmProvider } from "../../llm/provider";
+import type { Database } from "bun:sqlite";
+
+export function registerFollowUpsTool(
+  db: Database,
+  router: MessageRouter,
+  config: ZuboConfig,
+  llm?: LlmProvider
+) {
+  registerTool({
+    definition: {
+      name: "follow_ups",
+      description:
+        "Schedule, list, or cancel follow-up messages. Use this when you want to proactively check in with the user about something later — e.g., after they mention a dentist appointment, interview, or task they're working on. The follow-up fires as a proactive message at the scheduled time.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["schedule", "list", "cancel"],
+            description:
+              "Action to perform: schedule (create a follow-up), list (show pending), cancel (remove one)",
+          },
+          context: {
+            type: "string",
+            description:
+              'What the follow-up is about (for schedule). E.g., "dentist appointment", "job interview at Google"',
+          },
+          message: {
+            type: "string",
+            description:
+              'The message to send when following up (for schedule). E.g., "Hey! How did the dentist appointment go?"',
+          },
+          delay: {
+            type: "string",
+            description:
+              'When to follow up (for schedule). E.g., "in 2 hours", "tomorrow morning", "in 3 days"',
+          },
+          id: {
+            type: "number",
+            description: "Follow-up ID to cancel (for cancel)",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const { action, context, message, delay, id } = input as {
+        action: string;
+        context?: string;
+        message?: string;
+        delay?: string;
+        id?: number;
+      };
+
+      if (action === "schedule") {
+        if (!context || !message || !delay) {
+          return "Error: context, message, and delay are required to schedule a follow-up.";
+        }
+
+        // Parse the delay into a one-shot cron schedule
+        const delayText = delay.toLowerCase().startsWith("in ")
+          ? delay
+          : `in ${delay}`;
+        const parsed = parseNaturalSchedule(delayText);
+
+        if (typeof parsed === "string" || !parsed.once) {
+          return `Error: "${delay}" does not look like a one-shot delay. Use formats like "in 2 hours", "in 30 minutes", or "in 3 days".`;
+        }
+
+        const followUpAt = parsed.cron; // ISO 8601 string
+
+        // Insert the follow-up record
+        const result = db
+          .prepare(
+            "INSERT INTO follow_ups (context, message, follow_up_at) VALUES (?, ?, ?)"
+          )
+          .run(context, message, followUpAt);
+
+        const followUpId = Number(result.lastInsertRowid);
+        const cronName = `followup-${followUpId}`;
+
+        // Create a one-shot cron job to fire the proactive message
+        try {
+          addCronJob(
+            db,
+            cronName,
+            followUpAt,
+            message,
+            router,
+            config,
+            undefined,
+            llm,
+            true
+          );
+        } catch (err: any) {
+          // Clean up the follow-up record if cron creation fails
+          db.prepare("DELETE FROM follow_ups WHERE id = ?").run(followUpId);
+          return `Error scheduling follow-up: ${err.message}`;
+        }
+
+        const fireDate = new Date(followUpAt);
+        const fireTime = fireDate.toLocaleTimeString([], {
+          hour: "2-digit",
+          minute: "2-digit",
+        });
+        const fireDay = fireDate.toLocaleDateString([], {
+          weekday: "short",
+          month: "short",
+          day: "numeric",
+        });
+
+        return `Follow-up scheduled for ${fireDay} at ${fireTime}: "${message}"`;
+      }
+
+      if (action === "list") {
+        const rows = db
+          .query(
+            "SELECT * FROM follow_ups WHERE status = 'pending' ORDER BY follow_up_at"
+          )
+          .all() as Array<{
+          id: number;
+          context: string;
+          message: string;
+          follow_up_at: string;
+        }>;
+
+        if (rows.length === 0) return "No pending follow-ups.";
+
+        return rows
+          .map((row) => {
+            const relative = formatRelativeTime(new Date(row.follow_up_at));
+            return `${row.id}. ${row.context} — ${relative}\n   Message: "${row.message}"`;
+          })
+          .join("\n\n");
+      }
+
+      if (action === "cancel") {
+        if (!id) {
+          return "Error: id is required to cancel a follow-up.";
+        }
+
+        const row = db
+          .query("SELECT * FROM follow_ups WHERE id = ? AND status = 'pending'")
+          .get(id) as { id: number } | null;
+
+        if (!row) {
+          return `No pending follow-up found with ID ${id}.`;
+        }
+
+        db.prepare(
+          "UPDATE follow_ups SET status = 'cancelled' WHERE id = ?"
+        ).run(id);
+
+        // Try to remove the corresponding cron job
+        const cronName = `followup-${id}`;
+        removeCronJob(db, cronName);
+
+        return `Follow-up #${id} cancelled.`;
+      }
+
+      return `Unknown action: ${action}. Use schedule, list, or cancel.`;
+    },
+  });
+}
+
+/**
+ * Format a future date as a human-readable relative time string.
+ */
+function formatRelativeTime(date: Date): string {
+  const now = Date.now();
+  const diffMs = date.getTime() - now;
+
+  if (diffMs < 0) return "overdue";
+
+  const minutes = Math.floor(diffMs / 60_000);
+  const hours = Math.floor(diffMs / 3_600_000);
+  const days = Math.floor(diffMs / 86_400_000);
+
+  if (minutes < 1) return "any moment now";
+  if (minutes < 60) return `in ${minutes} minute${minutes === 1 ? "" : "s"}`;
+  if (hours < 24) return `in ${hours} hour${hours === 1 ? "" : "s"}`;
+  return `in ${days} day${days === 1 ? "" : "s"}`;
+}

package/src/tools/builtin/notes.ts

@@ -0,0 +1,207 @@
+import { registerTool } from "../registry";
+import { getDb } from "../../db/connection";
+
+interface NoteRow {
+  id: number;
+  title: string;
+  content: string;
+  tags: string;
+  pinned: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export function registerNotesTool() {
+  registerTool({
+    definition: {
+      name: "notes",
+      description:
+        "Manage the user's notes. Save, search, list, update, delete, or pin notes with tags and full-text search.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["save", "search", "list", "update", "delete", "pin"],
+            description: "The action to perform on notes.",
+          },
+          title: {
+            type: "string",
+            description: "Title of the note (for save).",
+          },
+          content: {
+            type: "string",
+            description: "Content of the note (for save/update).",
+          },
+          tags: {
+            type: "string",
+            description:
+              "Comma-separated tags (for save/update). Example: 'work, ideas'.",
+          },
+          query: {
+            type: "string",
+            description: "Search query for full-text search (for search).",
+          },
+          id: {
+            type: "number",
+            description: "Note ID (for update/delete/pin).",
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of results to return (for list/search). Default: 10.",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const db = getDb();
+      const action = input.action as string;
+
+      if (action === "save") {
+        const title = input.title as string;
+        const content = input.content as string;
+        if (!title) return "Error: title is required to save a note.";
+        if (!content) return "Error: content is required to save a note.";
+
+        const tags = input.tags
+          ? JSON.stringify(
+              (input.tags as string).split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+            )
+          : "[]";
+
+        const result = db
+          .prepare(
+            "INSERT INTO notes (title, content, tags) VALUES (?, ?, ?)"
+          )
+          .run(title, content, tags);
+
+        return `Note saved: #${result.lastInsertRowid} ${title}`;
+      }
+
+      if (action === "search") {
+        const query = input.query as string;
+        if (!query) return "Error: query is required for search.";
+
+        const limit = (input.limit as number) || 10;
+
+        const rows = db
+          .prepare(
+            `SELECT n.* FROM notes n
+             JOIN notes_fts f ON n.id = f.rowid
+             WHERE notes_fts MATCH ?
+             ORDER BY rank
+             LIMIT ?`
+          )
+          .all(query, limit) as NoteRow[];
+
+        if (rows.length === 0) return `No notes found matching "${query}".`;
+
+        const lines = rows.map((row) => formatNote(row));
+        return `Search results (${rows.length} found):\n${lines.join("\n")}`;
+      }
+
+      if (action === "list") {
+        const limit = (input.limit as number) || 10;
+
+        const rows = db
+          .prepare(
+            "SELECT * FROM notes ORDER BY pinned DESC, updated_at DESC LIMIT ?"
+          )
+          .all(limit) as NoteRow[];
+
+        if (rows.length === 0) return "No notes found.";
+
+        const lines = rows.map((row) => formatNote(row));
+        return `Notes (${rows.length} total):\n${lines.join("\n")}`;
+      }
+
+      if (action === "update") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to update a note.";
+
+        const updates: string[] = [];
+        const values: (string | null)[] = [];
+
+        if (input.title) {
+          updates.push("title = ?");
+          values.push(input.title as string);
+        }
+        if (input.content) {
+          updates.push("content = ?");
+          values.push(input.content as string);
+        }
+        if (input.tags !== undefined) {
+          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.";
+
+        updates.push("updated_at = datetime('now')");
+        values.push(String(id));
+
+        const changes = db
+          .prepare(`UPDATE notes SET ${updates.join(", ")} WHERE id = ?`)
+          .run(...values);
+
+        if (changes.changes === 0) return `No note found with id #${id}.`;
+        return `Updated note #${id}.`;
+      }
+
+      if (action === "delete") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to delete a note.";
+
+        const changes = db
+          .prepare("DELETE FROM notes WHERE id = ?")
+          .run(id);
+
+        if (changes.changes === 0) return `No note found with id #${id}.`;
+        return `Deleted note #${id}.`;
+      }
+
+      if (action === "pin") {
+        const id = input.id as number;
+        if (!id) return "Error: id is required to pin/unpin a note.";
+
+        const changes = db
+          .prepare("UPDATE notes SET pinned = NOT pinned WHERE id = ?")
+          .run(id);
+
+        if (changes.changes === 0) return `No note found with id #${id}.`;
+
+        const row = db
+          .prepare("SELECT pinned FROM notes WHERE id = ?")
+          .get(id) as { pinned: number } | null;
+
+        const state = row?.pinned ? "pinned" : "unpinned";
+        return `Note #${id} is now ${state}.`;
+      }
+
+      return `Unknown action: ${action}. Use save, search, list, update, delete, or pin.`;
+    },
+  });
+}
+
+function formatNote(row: NoteRow): string {
+  const pin = row.pinned ? "📌 " : "";
+  const preview =
+    row.content.length > 80
+      ? row.content.slice(0, 80) + "..."
+      : row.content;
+  let line = `${pin}#${row.id} ${row.title}`;
+
+  if (row.tags && row.tags !== "[]") {
+    const tagList = JSON.parse(row.tags) as string[];
+    if (tagList.length > 0) line += ` [${tagList.join(", ")}]`;
+  }
+
+  line += ` — ${preview}`;
+  return line;
+}

package/src/tools/builtin/preferences.ts

@@ -0,0 +1,173 @@
+import { registerTool } from "../registry";
+
+export function registerPreferencesTool() {
+  registerTool({
+    definition: {
+      name: "preferences",
+      description:
+        "Manage user preferences. Use this to remember things the user likes, prefers, or wants you to know about them. Preferences are organized by category (communication, work, coding, food, schedule, general, etc.) and stored as key-value pairs.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["set", "get", "list", "remove"],
+            description:
+              "Action to perform: set (save a preference), get (retrieve one), list (show all), remove (delete one)",
+          },
+          category: {
+            type: "string",
+            description:
+              'Category for the preference (e.g., "communication", "work", "coding", "food", "schedule", "general")',
+          },
+          key: {
+            type: "string",
+            description:
+              'Preference key (e.g., "preferred_language", "meeting_time", "coffee_order")',
+          },
+          value: {
+            type: "string",
+            description: "Preference value (required for set)",
+          },
+          confidence: {
+            type: "number",
+            description:
+              "Confidence level 0-1. Defaults to 0.9 for explicit user-set preferences.",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const { action, category, key, value, confidence } = input as {
+        action: string;
+        category?: string;
+        key?: string;
+        value?: string;
+        confidence?: number;
+      };
+
+      const { getDb } = await import("../../db/connection");
+      const db = getDb();
+
+      if (action === "set") {
+        if (!category || !key || !value) {
+          return "Error: category, key, and value are required to set a preference.";
+        }
+        const conf = confidence ?? 0.9;
+        db.prepare(
+          `INSERT OR REPLACE INTO user_preferences (category, key, value, confidence, source, updated_at)
+           VALUES (?, ?, ?, ?, 'explicit', datetime('now'))`
+        ).run(category, key, value, conf);
+        return `Preference saved: ${category}/${key} = ${value}`;
+      }
+
+      if (action === "get") {
+        if (!category || !key) {
+          return "Error: category and key are required to get a preference.";
+        }
+        const row = db
+          .query("SELECT value FROM user_preferences WHERE category = ? AND key = ?")
+          .get(category, key) as { value: string } | null;
+        if (!row) return "No preference found.";
+        return row.value;
+      }
+
+      if (action === "list") {
+        const rows = db
+          .query("SELECT * FROM user_preferences ORDER BY category, key")
+          .all() as Array<{
+          category: string;
+          key: string;
+          value: string;
+          confidence: number;
+        }>;
+
+        if (rows.length === 0) return "No preferences saved yet.";
+
+        let result = "";
+        let currentCategory = "";
+        for (const row of rows) {
+          if (row.category !== currentCategory) {
+            currentCategory = row.category;
+            result += `\n## ${capitalize(currentCategory)}\n`;
+          }
+          result += `- ${row.key}: ${row.value} (confidence: ${row.confidence})\n`;
+        }
+        return result.trim();
+      }
+
+      if (action === "remove") {
+        if (!category || !key) {
+          return "Error: category and key are required to remove a preference.";
+        }
+        const changes = db
+          .prepare("DELETE FROM user_preferences WHERE category = ? AND key = ?")
+          .run(category, key).changes;
+        if (changes > 0) return `Preference removed: ${category}/${key}`;
+        return `No preference found for ${category}/${key}.`;
+      }
+
+      return `Unknown action: ${action}. Use set, get, list, or remove.`;
+    },
+  });
+}
+
+function capitalize(s: string): string {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/**
+ * Detect obvious preference signals in a user message.
+ * This is intentionally conservative — the LLM should handle nuanced
+ * preference extraction by calling the preferences tool directly.
+ */
+export function extractPreferences(
+  message: string
+): Array<{ category: string; key: string; value: string }> {
+  const prefs: Array<{ category: string; key: string; value: string }> = [];
+  const _lower = message.toLowerCase();
+
+  // "I prefer X" / "I like X" / "I always use X"
+  const _preferPatterns = [
+    /i (?:prefer|like|love|always use|usually use|tend to use)\s+(.+?)(?:\s+(?:for|when|over|instead)\b|[.,!]|$)/gi,
+    /my (?:favorite|preferred|go-to)\s+(\w+)\s+is\s+(.+?)(?:[.,!]|$)/gi,
+    /i'm a (\w+)\s+person/gi,
+    /(?:call me|my name is|i'm|i am)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/g,
+  ];
+
+  // Don't try to be too smart — just detect obvious signals
+  // The LLM should handle the actual preference extraction via the tool
+  return prefs;
+}
+
+/**
+ * Load all user preferences into a formatted string suitable for
+ * injection into the system prompt, giving the agent context about the user.
+ */
+export async function loadPreferencesContext(): Promise<string> {
+  try {
+    const { getDb } = await import("../../db/connection");
+    const db = getDb();
+    const rows = db
+      .query(
+        "SELECT category, key, value FROM user_preferences ORDER BY category, key"
+      )
+      .all() as Array<{ category: string; key: string; value: string }>;
+
+    if (rows.length === 0) return "";
+
+    let context = "## User preferences\n";
+    let currentCat = "";
+    for (const row of rows) {
+      if (row.category !== currentCat) {
+        currentCat = row.category;
+        context += `\n**${currentCat}:**\n`;
+      }
+      context += `- ${row.key}: ${row.value}\n`;
+    }
+    return context;
+  } catch {
+    return "";
+  }
+}