zubo 0.1.0

package/src/tools/builtin/connect-service.ts

@@ -0,0 +1,205 @@
+import { registerTool } from "../registry";
+import { listAvailableIntegrations, installIntegration } from "../integration-installer";
+import { setSecret } from "../../secrets/store";
+import { loadSkills } from "../skill-loader";
+import { paths } from "../../config/paths";
+import { logger } from "../../util/logger";
+
+export function registerConnectServiceTool() {
+  registerTool({
+    definition: {
+      name: "connect_service",
+      description:
+        "Connect an external service (GitHub, Google, Notion, etc.) by storing credentials and installing pre-built integration skills. Use action 'list' to see available integrations, or 'connect' to set up a service.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "connect"],
+            description: "The action to perform",
+          },
+          service: {
+            type: "string",
+            description:
+              "Service name to connect (e.g., 'github', 'google', 'notion'). Required for connect.",
+          },
+          credentials: {
+            type: "object",
+            description:
+              "Key-value pairs of credential names and values (e.g., { \"github_token\": \"ghp_...\" }). Required for connect.",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const { action, service, credentials } = input as {
+        action: string;
+        service?: string;
+        credentials?: Record<string, string>;
+      };
+
+      switch (action) {
+        case "list": {
+          const integrations = listAvailableIntegrations();
+          if (integrations.length === 0) {
+            return "No integrations available.";
+          }
+          return JSON.stringify({
+            integrations: integrations.map((i) => ({
+              service: i.service,
+              skills: i.skills,
+              required_secret: i.secret_name,
+            })),
+          });
+        }
+
+        case "connect": {
+          if (!service) {
+            return JSON.stringify({ error: "service is required for connect" });
+          }
+
+          // Validate service name to prevent path traversal
+          if (!/^[a-z0-9_-]+$/.test(service)) {
+            return JSON.stringify({
+              error: "Invalid service name. Must contain only lowercase letters, numbers, hyphens, and underscores.",
+            });
+          }
+
+          // Google uses OAuth 2.0 -- redirect to the google_oauth tool
+          if (service === "google") {
+            // If client_id and client_secret are provided, store them for the OAuth flow
+            if (credentials) {
+              if (credentials.client_id) {
+                setSecret("google_client_id", credentials.client_id, "google");
+              }
+              if (credentials.client_secret) {
+                setSecret("google_client_secret", credentials.client_secret, "google");
+              }
+            }
+
+            // Install the integration skill templates
+            const installed = installIntegration(paths.skills, service);
+            if (installed.length > 0) {
+              try {
+                await loadSkills(paths.skills);
+                logger.info(`Google integration skills installed: ${installed.join(", ")}`);
+              } catch (err: any) {
+                logger.error(`Failed to load Google integration skills: ${err.message}`);
+              }
+            }
+
+            return JSON.stringify({
+              success: true,
+              service: "google",
+              skills_installed: installed,
+              message:
+                "Google integration skills installed. Google requires OAuth 2.0 to authenticate. " +
+                "You need TWO credentials from the user: " +
+                "(1) client_id (ends with .apps.googleusercontent.com) and " +
+                "(2) client_secret (starts with GOCSPX-). " +
+                "These are different values — ask for both separately.",
+              next_step:
+                "Ask the user for both their Google OAuth client_id AND client_secret, " +
+                "then call google_oauth with action 'start' passing both values.",
+            });
+          }
+
+          // Validate required credentials per service
+          const REQUIRED_SECRETS: Record<string, { keys: string[]; guide: string }> = {
+            github: {
+              keys: ["github_token"],
+              guide: "Requires a GitHub Personal Access Token (PAT). Get one at: GitHub > Settings > Developer settings > Personal access tokens. Needs scopes: repo, read:org.",
+            },
+            notion: {
+              keys: ["notion_token"],
+              guide: "Requires a Notion Internal Integration Token. Create one at: notion.so/my-integrations. Then share your pages/databases with the integration.",
+            },
+            linear: {
+              keys: ["linear_token"],
+              guide: "Requires a Linear Personal API Key. Get one at: Linear > Settings > API > Personal API keys.",
+            },
+            slack: {
+              keys: ["slack_token"],
+              guide: "Requires a Slack Bot Token (xoxb-...). Create a Slack app at api.slack.com/apps, add Bot Token Scopes (channels:read, channels:history, chat:write, search:read), then install to workspace.",
+            },
+            jira: {
+              keys: ["jira_token", "jira_email", "jira_url"],
+              guide: "Requires 3 credentials: jira_email (your Atlassian email), jira_token (API token from id.atlassian.com/manage-profile/security/api-tokens), and jira_url (e.g. https://yourteam.atlassian.net).",
+            },
+            twitter: {
+              keys: ["twitter_bearer_token"],
+              guide: "For reading: provide twitter_bearer_token (from developer.twitter.com > App > Keys and tokens). For posting: also need twitter_api_key, twitter_api_secret, twitter_access_token, twitter_access_secret.",
+            },
+          };
+
+          const serviceInfo = REQUIRED_SECRETS[service];
+
+          // If no credentials provided, return guidance
+          if (!credentials || Object.keys(credentials).length === 0) {
+            if (serviceInfo) {
+              return JSON.stringify({
+                error: "No credentials provided.",
+                required_secrets: serviceInfo.keys,
+                guide: serviceInfo.guide,
+              });
+            }
+          }
+
+          // Store credentials
+          if (credentials) {
+            for (const [name, value] of Object.entries(credentials)) {
+              setSecret(name, value, service);
+            }
+          }
+
+          // Check if all required keys were provided
+          let missingKeys: string[] = [];
+          if (serviceInfo) {
+            for (const key of serviceInfo.keys) {
+              if (!credentials || !credentials[key]) {
+                missingKeys.push(key);
+              }
+            }
+          }
+
+          // Install integration skills
+          const installed = installIntegration(paths.skills, service);
+          if (installed.length === 0) {
+            return JSON.stringify({
+              error: `No integration templates found for service "${service}". Credentials were stored if provided.`,
+            });
+          }
+
+          // Hot-load newly installed skills
+          try {
+            const loaded = await loadSkills(paths.skills);
+            logger.info(
+              `Integration "${service}" connected. Skills: ${installed.join(", ")}`
+            );
+          } catch (err: any) {
+            logger.error(`Failed to load integration skills: ${err.message}`);
+          }
+
+          const result: Record<string, unknown> = {
+            success: true,
+            service,
+            skills_installed: installed,
+            message: `Service "${service}" connected. ${installed.length} skill(s) installed and ready: ${installed.join(", ")}`,
+          };
+
+          if (missingKeys.length > 0) {
+            result.warning = `Missing credentials: ${missingKeys.join(", ")}. Some features may not work.`;
+            if (serviceInfo) result.guide = serviceInfo.guide;
+          }
+
+          return JSON.stringify(result);
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${action}` });
+      }
+    },
+  });
+}

package/src/tools/builtin/cron.ts

@@ -0,0 +1,126 @@
+import { registerTool } from "../registry";
+import { addCronJob, removeCronJob, listCronJobs } 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 registerCronTools(
+  db: Database,
+  router: MessageRouter,
+  config: ZuboConfig,
+  llm?: LlmProvider
+) {
+  registerTool({
+    definition: {
+      name: "cron_create",
+      description:
+        "Create a scheduled task that runs on a cron schedule. Schedule can be a cron expression (e.g. '0 9 * * 1-5') or natural language (e.g. 'every weekday at 9am', 'every 30 minutes', 'daily at noon'). The task is a natural language instruction that the agent will execute at the scheduled time. Optionally assign to a specific sub-agent.",
+      input_schema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description:
+              "A unique name for this task (e.g., 'morning-briefing', 'pr-review-reminder')",
+          },
+          schedule: {
+            type: "string",
+            description:
+              "Cron expression (e.g., '0 9 * * 1-5') or natural language (e.g., 'every weekday at 9am', 'every monday and friday at noon', 'every 30 minutes', 'daily at 8:30am')",
+          },
+          task: {
+            type: "string",
+            description:
+              "The task to perform, as a natural language instruction (e.g., 'Send a morning briefing with weather and calendar summary')",
+          },
+          agent: {
+            type: "string",
+            description:
+              "Optional: name of a sub-agent to delegate this task to. The agent must be created with manage_agents first.",
+          },
+        },
+        required: ["name", "schedule", "task"],
+      },
+    },
+    execute: async (input) => {
+      const { name, schedule, task, agent } = input as {
+        name: string;
+        schedule: string;
+        task: string;
+        agent?: string;
+      };
+      try {
+        let cronExpr = schedule;
+        let naturalParseError = "";
+        try {
+          cronExpr = parseNaturalSchedule(schedule);
+        } catch (parseErr: any) {
+          naturalParseError = parseErr.message;
+          // Only fall through if it looks like raw cron (5 space-separated fields)
+          if (!/^[\d*\/,\-]+(\s+[\d*\/,\-]+){4}$/.test(schedule.trim())) {
+            throw new Error(naturalParseError);
+          }
+        }
+        addCronJob(db, name, cronExpr, task, router, config, agent, llm);
+        let msg = `Scheduled task "${name}" created.\nSchedule: ${cronExpr}`;
+        if (cronExpr !== schedule) msg += ` (parsed from "${schedule}")`;
+        msg += `\nTask: ${task}`;
+        if (agent) msg += `\nAgent: ${agent}`;
+        return msg;
+      } catch (err: any) {
+        if (err.message?.includes("UNIQUE constraint")) {
+          return `Error: A task named "${name}" already exists. Use a different name or delete the existing one first.`;
+        }
+        throw err;
+      }
+    },
+  });
+
+  registerTool({
+    definition: {
+      name: "cron_list",
+      description:
+        "List all scheduled tasks with their status, schedule, and last run time.",
+      input_schema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    execute: async () => {
+      const jobs = listCronJobs(db);
+      if (jobs.length === 0) return "No scheduled tasks found.";
+
+      return jobs
+        .map(
+          (j) =>
+            `- ${j.name} [${j.enabled ? "active" : "disabled"}]\n  Schedule: ${j.schedule}\n  Task: ${j.task}${j.agent ? `\n  Agent: ${j.agent}` : ""}\n  Last run: ${j.last_run ?? "never"}`
+        )
+        .join("\n\n");
+    },
+  });
+
+  registerTool({
+    definition: {
+      name: "cron_delete",
+      description: "Delete a scheduled task by name.",
+      input_schema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "The name of the scheduled task to delete",
+          },
+        },
+        required: ["name"],
+      },
+    },
+    execute: async (input) => {
+      const { name } = input as { name: string };
+      const removed = removeCronJob(db, name);
+      if (removed) return `Scheduled task "${name}" has been deleted.`;
+      return `No scheduled task found with name "${name}".`;
+    },
+  });
+}

package/src/tools/builtin/datetime.ts

@@ -0,0 +1,36 @@
+import { registerTool } from "../registry";
+
+export function registerDatetimeTool() {
+  registerTool({
+    definition: {
+      name: "get_current_datetime",
+      description:
+        "Get the current date and time in ISO format, with optional timezone.",
+      input_schema: {
+        type: "object",
+        properties: {
+          timezone: {
+            type: "string",
+            description:
+              "IANA timezone (e.g. 'Europe/Berlin'). Defaults to UTC.",
+          },
+        },
+        required: [],
+      },
+    },
+    execute: async (input) => {
+      const tz = (input.timezone as string) || "UTC";
+      const now = new Date();
+      const formatted = now.toLocaleString("en-US", {
+        timeZone: tz,
+        dateStyle: "full",
+        timeStyle: "long",
+      });
+      return JSON.stringify({
+        iso: now.toISOString(),
+        formatted,
+        timezone: tz,
+      });
+    },
+  });
+}

package/src/tools/builtin/delegate-task.ts

@@ -0,0 +1,81 @@
+import { registerTool } from "../registry";
+import type { LlmProvider } from "../../llm/provider";
+import { logger } from "../../util/logger";
+
+export function registerDelegateTaskTool(llm: LlmProvider): void {
+  registerTool({
+    definition: {
+      name: "delegate_task",
+      description:
+        "Delegate a subtask to an ad-hoc sub-agent. The sub-agent runs a fresh agent loop with its own context. Use for complex tasks that benefit from focused, independent processing. Unlike 'delegate', this does not require a pre-registered agent.",
+      input_schema: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: "Clear description of the subtask to delegate",
+          },
+          context: {
+            type: "string",
+            description:
+              "Optional additional context or constraints for the sub-agent",
+          },
+        },
+        required: ["task"],
+      },
+    },
+    execute: async (input) => {
+      const task = input.task as string;
+      const context = input.context as string | undefined;
+
+      if (!task) {
+        return JSON.stringify({ error: "task is required" });
+      }
+
+      // Dynamic imports to avoid circular dependencies
+      const { agentLoop } = await import("../../agent/loop");
+      const crypto = await import("crypto");
+
+      const subSessionId = "delegate-task-" + crypto.randomUUID().slice(0, 8);
+
+      const message = context
+        ? `${task}\n\nAdditional context: ${context}`
+        : task;
+
+      logger.info("Delegating subtask to ad-hoc sub-agent", {
+        task: task.slice(0, 100),
+        sessionId: subSessionId,
+      });
+
+      try {
+        // Exclude delegation tools to prevent recursive delegation
+        const { getAllToolDefs } = await import("../registry");
+        const allowedTools = getAllToolDefs()
+          .map((t) => t.name)
+          .filter((n) => n !== "delegate_task" && n !== "delegate");
+
+        const result = await agentLoop(llm, subSessionId, message, {
+          systemPromptOverride:
+            "You are a focused sub-agent. Complete the given task concisely and return the result. Do not ask follow-up questions.",
+          maxRounds: 5,
+          allowedTools,
+        });
+
+        logger.info("Sub-agent completed", {
+          sessionId: subSessionId,
+          toolCalls: result.toolCalls,
+        });
+
+        return result.reply;
+      } catch (err: unknown) {
+        const errorMessage =
+          err instanceof Error ? err.message : String(err);
+        logger.error("Sub-agent failed", {
+          error: errorMessage,
+          sessionId: subSessionId,
+        });
+        return "Delegation failed: " + errorMessage;
+      }
+    },
+  });
+}

package/src/tools/builtin/delegate.ts

@@ -0,0 +1,42 @@
+import { registerTool } from "../registry";
+import type { LlmProvider } from "../../llm/provider";
+
+export function registerDelegateTool(llm: LlmProvider) {
+  registerTool({
+    definition: {
+      name: "delegate",
+      description:
+        "Delegate a task to a named sub-agent. The sub-agent runs with its own system prompt and scoped tools, shares memory, but keeps separate conversation history. Use manage_agents to create agents first.",
+      input_schema: {
+        type: "object",
+        properties: {
+          agent: {
+            type: "string",
+            description: "The name of the agent to delegate to",
+          },
+          task: {
+            type: "string",
+            description:
+              "The task to delegate, as a natural language instruction",
+          },
+        },
+        required: ["agent", "task"],
+      },
+    },
+    execute: async (input) => {
+      const { agent, task } = input as { agent: string; task: string };
+
+      if (!agent) {
+        return JSON.stringify({ error: "agent name is required" });
+      }
+      if (!task) {
+        return JSON.stringify({ error: "task is required" });
+      }
+
+      // Dynamic import to avoid circular dependency
+      const { delegateToAgent } = await import("../../agent/delegate");
+      const result = await delegateToAgent(llm, agent, task);
+      return result;
+    },
+  });
+}

package/src/tools/builtin/diagnose.ts

@@ -0,0 +1,41 @@
+import { registerTool } from "../registry";
+import { getRecentErrors } from "../../util/error-buffer";
+
+export function registerDiagnoseTool(): void {
+  registerTool({
+    definition: {
+      name: "diagnose",
+      description:
+        "Check recent errors and system health. Use when something seems wrong or the user reports an issue.",
+      input_schema: {
+        type: "object",
+        properties: {
+          category: {
+            type: "string",
+            description:
+              "Optional error category filter (e.g. 'agent-loop', 'tool:shell')",
+          },
+        },
+        required: [],
+      },
+    },
+    execute: async (input) => {
+      const category = input.category as string | undefined;
+      const errors = getRecentErrors();
+
+      const filtered = category
+        ? errors.filter((e) => e.source.includes(category))
+        : errors;
+
+      if (filtered.length === 0) {
+        return "No recent errors found. System appears healthy.";
+      }
+
+      const summary = filtered
+        .map((e) => `[${e.timestamp}] ${e.source}: ${e.message}`)
+        .join("\n");
+
+      return `Found ${filtered.length} recent error(s):\n${summary}`;
+    },
+  });
+}