zubo 0.1.0

package/src/scheduler/natural-cron.ts

@@ -0,0 +1,163 @@
+/**
+ * Parse natural language schedule descriptions into cron expressions.
+ * Returns a standard 5-field cron expression (minute hour day month weekday).
+ * Throws if the input can't be parsed.
+ */
+export function parseNaturalSchedule(input: string): string {
+  const text = input.toLowerCase().trim();
+
+  // Direct cron expression passthrough — only accept standard 5-field cron
+  if (/^[\d*\/,\-]+(\s+[\d*\/,\-]+){4}$/.test(text)) return text;
+
+  // Time parsing helper
+  function parseTime(s: string): { hour: number; minute: number } | null {
+    // "9am", "9:30am", "9:30 am", "14:00", "2pm", "noon", "midnight"
+    if (/noon/i.test(s)) return { hour: 12, minute: 0 };
+    if (/midnight/i.test(s)) return { hour: 0, minute: 0 };
+
+    const match = s.match(/(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i);
+    if (!match) return null;
+
+    let hour = parseInt(match[1], 10);
+    const minute = match[2] ? parseInt(match[2], 10) : 0;
+    const ampm = match[3]?.toLowerCase();
+
+    if (ampm === "pm" && hour < 12) hour += 12;
+    if (ampm === "am" && hour === 12) hour = 0;
+
+    if (hour > 23 || minute > 59) return null;
+    return { hour, minute };
+  }
+
+  // Day of week mapping
+  const dayMap: Record<string, number> = {
+    sunday: 0, sun: 0,
+    monday: 1, mon: 1,
+    tuesday: 2, tue: 2, tues: 2,
+    wednesday: 3, wed: 3,
+    thursday: 4, thu: 4, thur: 4, thurs: 4,
+    friday: 5, fri: 5,
+    saturday: 6, sat: 6,
+  };
+
+  // Extract time from the text
+  function findTime(): { hour: number; minute: number } {
+    // Look for "at <time>" pattern
+    const atMatch = text.match(/at\s+(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)/i);
+    if (atMatch) {
+      const t = parseTime(atMatch[1]);
+      if (t) return t;
+    }
+    // Look for standalone time
+    const timeMatch = text.match(/(\d{1,2}(?::\d{2})\s*(?:am|pm)?)/i) || text.match(/(\d{1,2}\s*(?:am|pm))/i);
+    if (timeMatch) {
+      const t = parseTime(timeMatch[1]);
+      if (t) return t;
+    }
+    // "noon", "midnight"
+    if (/noon/.test(text)) return { hour: 12, minute: 0 };
+    if (/midnight/.test(text)) return { hour: 0, minute: 0 };
+    // "morning" = 9am, "evening" = 6pm, "night" = 9pm
+    if (/\bmorning\b/.test(text)) return { hour: 9, minute: 0 };
+    if (/\bevening\b/.test(text)) return { hour: 18, minute: 0 };
+    if (/\bnight\b/.test(text)) return { hour: 21, minute: 0 };
+    // Default to 9am
+    return { hour: 9, minute: 0 };
+  }
+
+  // --- Pattern matching ---
+
+  // "every X minutes/hours"
+  const everyMinMatch = text.match(/every\s+(\d+)\s*min(?:ute)?s?/i);
+  if (everyMinMatch) {
+    const mins = parseInt(everyMinMatch[1], 10);
+    if (mins < 1 || mins > 59) throw new Error("Interval must be between 1-59 minutes");
+    return `*/${mins} * * * *`;
+  }
+
+  const everyHourMatch = text.match(/every\s+(\d+)\s*hours?/i);
+  if (everyHourMatch) {
+    const hrs = parseInt(everyHourMatch[1], 10);
+    if (hrs < 1 || hrs > 23) throw new Error("Interval must be between 1-23 hours");
+    return `0 */${hrs} * * *`;
+  }
+
+  // "every hour"
+  if (/every\s+hour\b/i.test(text)) return "0 * * * *";
+
+  // "every day at <time>" or "daily at <time>"
+  if (/(?:every\s+day|daily)\b/i.test(text)) {
+    const t = findTime();
+    return `${t.minute} ${t.hour} * * *`;
+  }
+
+  // "every weekday at <time>" or "weekdays at <time>"
+  if (/(?:every\s+)?weekday/i.test(text)) {
+    const t = findTime();
+    return `${t.minute} ${t.hour} * * 1-5`;
+  }
+
+  // "every weekend at <time>"
+  if (/(?:every\s+)?weekend/i.test(text)) {
+    const t = findTime();
+    return `${t.minute} ${t.hour} * * 0,6`;
+  }
+
+  // "every monday at <time>", "every mon, wed, fri at <time>"
+  // Extract everything between "every" and "at" (or end) to find day names
+  const everyDayMatch = text.match(/every\s+(.+?)(?:\s+at\s+|$)/i);
+  if (everyDayMatch) {
+    const dayStr = everyDayMatch[1].toLowerCase();
+    const days: number[] = [];
+    for (const [name, num] of Object.entries(dayMap)) {
+      const wordPattern = new RegExp(`\\b${name}\\b`);
+      if (wordPattern.test(dayStr)) {
+        if (!days.includes(num)) days.push(num);
+      }
+    }
+    if (days.length > 0) {
+      const t = findTime();
+      return `${t.minute} ${t.hour} * * ${days.sort().join(",")}`;
+    }
+  }
+
+  // "<weekday> at <time>" — single day with explicit "at" keyword
+  for (const [name, num] of Object.entries(dayMap)) {
+    const wordPattern = new RegExp(`\\b${name}\\b`);
+    if (wordPattern.test(text) && /\bat\b/.test(text)) {
+      const t = findTime();
+      return `${t.minute} ${t.hour} * * ${num}`;
+    }
+  }
+
+  // "every month on the <nth> at <time>" or "monthly on <nth>"
+  const monthlyMatch = text.match(/(?:every\s+month|monthly)\s+(?:on\s+)?(?:the\s+)?(\d{1,2})(?:st|nd|rd|th)?/i);
+  if (monthlyMatch) {
+    const day = parseInt(monthlyMatch[1], 10);
+    if (day < 1 || day > 31) throw new Error("Day must be between 1-31");
+    const t = findTime();
+    return `${t.minute} ${t.hour} ${day} * *`;
+  }
+
+  // "twice a day" -> 9am and 5pm
+  if (/twice\s+a\s+day/i.test(text)) return "0 9,17 * * *";
+
+  // "every morning" -> 9am daily
+  if (/every\s+morning/i.test(text)) return "0 9 * * *";
+
+  // "every evening" -> 6pm daily
+  if (/every\s+evening/i.test(text)) return "0 18 * * *";
+
+  // "every night" -> 9pm daily
+  if (/every\s+night/i.test(text)) return "0 21 * * *";
+
+  // Fallback: if there's just a time, assume daily
+  const t = findTime();
+  if (text.includes("at") || /\d{1,2}\s*(?:am|pm)/i.test(text)) {
+    return `${t.minute} ${t.hour} * * *`;
+  }
+
+  throw new Error(
+    `Could not parse schedule: "${input}". Try formats like "every day at 9am", "every weekday at 8:30am", "every monday and friday at noon", or "every 30 minutes".`
+  );
+}

package/src/scheduler/proactive.ts

@@ -0,0 +1,25 @@
+import { Database } from "bun:sqlite";
+import type { MessageRouter } from "../channels/router";
+import type { LlmProvider } from "../llm/provider";
+import type { ZuboConfig } from "../config/schema";
+import { onHeartbeat } from "./heartbeat";
+import { checkMemoryTriggers } from "./memory-triggers";
+import { logger } from "../util/logger";
+
+export function initProactiveIntelligence(
+  db: Database,
+  router: MessageRouter,
+  llm: LlmProvider,
+  _config: ZuboConfig
+): void {
+  // Register heartbeat handler for proactive checks
+  onHeartbeat(async () => {
+    try {
+      await checkMemoryTriggers(db, router, llm);
+    } catch (err: any) {
+      logger.error("Proactive trigger check failed", { error: err.message });
+    }
+  });
+
+  logger.info("Proactive intelligence initialized");
+}

package/src/scheduler/recipes.ts

@@ -0,0 +1,110 @@
+export interface WorkflowRecipe {
+  id: string;
+  name: string;
+  description: string;
+  category: "productivity" | "communication" | "development" | "monitoring";
+  icon: string;
+  schedule: string; // cron expression
+  scheduleHuman: string; // human-readable
+  task: string; // the prompt sent to the agent
+  requires?: string[]; // optional: integration names needed
+}
+
+export const WORKFLOW_RECIPES: WorkflowRecipe[] = [
+  {
+    id: "morning-briefing",
+    name: "Morning Briefing",
+    description: "Get a daily summary of your calendar, emails, and pending tasks every morning.",
+    category: "productivity",
+    icon: "☀️",
+    schedule: "0 9 * * 1-5",
+    scheduleHuman: "Weekdays at 9:00am",
+    task: "Generate a morning briefing. Check my calendar for today's events, summarize any new unread emails, and list any pending or urgent tasks. Format it as a concise digest with sections: 📅 Today's Calendar, 📧 Email Summary, ✅ Tasks.",
+  },
+  {
+    id: "email-triage",
+    name: "Email Triage",
+    description: "Automatically categorize and summarize incoming emails every few hours.",
+    category: "communication",
+    icon: "📧",
+    schedule: "0 */3 * * *",
+    scheduleHuman: "Every 3 hours",
+    task: "Check my recent emails from the last 3 hours. Categorize them as: 🔴 Urgent (needs reply today), 🟡 Important (needs reply this week), 🟢 FYI (no action needed), 🗑️ Skip (newsletters, spam). Give a one-line summary for each email.",
+    requires: ["gmail"],
+  },
+  {
+    id: "weekly-report",
+    name: "Weekly Report",
+    description: "Generate a weekly summary of activity, tasks completed, and key metrics.",
+    category: "productivity",
+    icon: "📊",
+    schedule: "0 17 * * 5",
+    scheduleHuman: "Fridays at 5:00pm",
+    task: "Generate a weekly report summarizing this week's activity. Include: conversations held, tools used, tasks completed via cron jobs, and any notable events. Format as a clean report with sections and bullet points.",
+  },
+  {
+    id: "github-digest",
+    name: "GitHub Digest",
+    description: "Daily summary of new issues, PRs, and activity across your repositories.",
+    category: "development",
+    icon: "🐙",
+    schedule: "0 10 * * 1-5",
+    scheduleHuman: "Weekdays at 10:00am",
+    task: "Check my GitHub repositories for activity in the last 24 hours. Summarize new issues, pull requests, and any PRs that need my review. Format as: 🔔 Needs Review, 🆕 New Issues, 📝 New PRs.",
+    requires: ["github"],
+  },
+  {
+    id: "standup-prep",
+    name: "Standup Prep",
+    description: "Prepare your daily standup notes based on recent activity.",
+    category: "development",
+    icon: "🎯",
+    schedule: "0 8 * * 1-5",
+    scheduleHuman: "Weekdays at 8:00am",
+    task: "Help me prepare for my daily standup. Based on my recent conversations and any tools used yesterday, draft standup notes in the format: ✅ What I did yesterday, 🔜 What I'm doing today, 🚧 Any blockers.",
+  },
+  {
+    id: "system-health",
+    name: "System Health Check",
+    description: "Monitor Zubo's health — database size, memory usage, error rates.",
+    category: "monitoring",
+    icon: "🏥",
+    schedule: "0 8 * * *",
+    scheduleHuman: "Daily at 8:00am",
+    task: "Run a system health check using the diagnose tool. Report on: database size, memory count, recent errors, cron job status, and any issues. Flag anything that needs attention.",
+  },
+  {
+    id: "calendar-reminder",
+    name: "Calendar Reminder",
+    description: "Get notified about upcoming meetings 15 minutes before they start.",
+    category: "productivity",
+    icon: "📅",
+    schedule: "*/15 * * * *",
+    scheduleHuman: "Every 15 minutes",
+    task: "Check my Google Calendar for any events starting in the next 15 minutes. If there are any, send me a brief reminder with the event name, time, and meeting link if available.",
+    requires: ["google_calendar"],
+  },
+  {
+    id: "news-digest",
+    name: "News & Trends Digest",
+    description: "Daily briefing of top news and trends relevant to your interests.",
+    category: "productivity",
+    icon: "📰",
+    schedule: "0 7 * * *",
+    scheduleHuman: "Daily at 7:00am",
+    task: "Search the web for today's top technology and AI news. Summarize the 5 most important stories in 1-2 sentences each. Focus on: AI developments, major tech announcements, and cybersecurity news.",
+  },
+];
+
+export function getRecipeById(id: string): WorkflowRecipe | undefined {
+  return WORKFLOW_RECIPES.find(r => r.id === id);
+}
+
+export function getRecipesByCategory(): Record<string, WorkflowRecipe[]> {
+  const result: Record<string, WorkflowRecipe[]> = {};
+  for (const recipe of WORKFLOW_RECIPES) {
+    if (!result[recipe.category]) result[recipe.category] = [];
+    result[recipe.category].push(recipe);
+  }
+  return result;
+}

package/src/secrets/store.ts

@@ -0,0 +1,64 @@
+import { getDb } from "../db/connection";
+
+export interface SecretInfo {
+  name: string;
+  service: string | null;
+  updated_at: string;
+}
+
+export function setSecret(name: string, value: string, service?: string): void {
+  const db = getDb();
+  db.prepare(
+    `INSERT INTO secrets (name, value, service, updated_at)
+     VALUES (?, ?, ?, datetime('now'))
+     ON CONFLICT(name) DO UPDATE SET value = excluded.value, service = excluded.service, updated_at = datetime('now')`
+  ).run(name, value, service ?? null);
+}
+
+export function getSecret(name: string): string | null {
+  const db = getDb();
+  const row = db.query("SELECT value FROM secrets WHERE name = ?").get(name) as
+    | { value: string }
+    | null;
+  return row?.value ?? null;
+}
+
+export function listSecrets(service?: string): SecretInfo[] {
+  const db = getDb();
+  if (service) {
+    return db
+      .query("SELECT name, service, updated_at FROM secrets WHERE service = ? ORDER BY name")
+      .all(service) as SecretInfo[];
+  }
+  return db
+    .query("SELECT name, service, updated_at FROM secrets ORDER BY name")
+    .all() as SecretInfo[];
+}
+
+export function deleteSecret(name: string): boolean {
+  const db = getDb();
+  const result = db.prepare("DELETE FROM secrets WHERE name = ?").run(name);
+  return result.changes > 0;
+}
+
+/**
+ * Exposes getSecret (and helpers) on globalThis.Zubo so user-created
+ * skill handlers can access secrets without relative imports.
+ */
+export function exposeSecretsRuntime(): void {
+  const g = globalThis as any;
+  if (!g.Zubo) g.Zubo = {};
+  g.Zubo.getSecret = getSecret;
+}
+
+/**
+ * Exposes getGoogleToken on globalThis.Zubo so installed Google skill
+ * handlers can get a valid OAuth access token without importing from src.
+ */
+export function exposeGoogleTokenRuntime(
+  getGoogleAccessToken: () => Promise<string>
+): void {
+  const g = globalThis as any;
+  if (!g.Zubo) g.Zubo = {};
+  g.Zubo.getGoogleToken = getGoogleAccessToken;
+}