zubo 0.1.0

package/src/tools/builtin/manage-skills.ts

@@ -0,0 +1,294 @@
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { paths } from "../../config/paths";
+import { registerTool, unregisterTool, getTool } from "../registry";
+import { parseSkillMd, parseSkillExport, paramsToJsonSchema } from "../skill-loader";
+import { logger } from "../../util/logger";
+
+export function registerManageSkillsTool() {
+  registerTool({
+    definition: {
+      name: "manage_skills",
+      description:
+        'Create, list, or remove skills (custom tools) at runtime. Use this when the user asks you to build, create, or make a new tool, skill, or utility — including phrases like "build a skill that...", "make me a tool to...", "create a skill for...". Also use for listing installed skills or removing one. Created skills are available immediately without restarting.',
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "remove"],
+            description: "The action to perform.",
+          },
+          name: {
+            type: "string",
+            description: "Skill name (lowercase, underscores only). Required for create and remove.",
+          },
+          description: {
+            type: "string",
+            description: "What the skill does. Required for create.",
+          },
+          input_schema: {
+            type: "object",
+            description:
+              "JSON Schema for the tool's input parameters. Should have type, properties, and required fields. Use this OR params (simplified format).",
+          },
+          params: {
+            type: "object",
+            description:
+              'Simplified parameter definitions. Each key is a param name with {type, description, required} fields. E.g. { "query": { "type": "string", "required": true } }. Use this OR input_schema.',
+          },
+          handler_code: {
+            type: "string",
+            description:
+              'TypeScript code for handler.ts. Must export a default async function that takes Record<string, unknown> and returns a Promise<string>. Required for create. Example: \'export default async function (input: Record<string, unknown>): Promise<string> { return JSON.stringify({ result: "hello" }); }\'',
+          },
+        },
+        required: ["action"],
+      },
+    },
+    execute: async (input) => {
+      const action = input.action as string;
+
+      switch (action) {
+        case "create":
+          return await createSkill(input);
+        case "list":
+          return listSkills();
+        case "remove":
+          return removeSkill(input);
+        default:
+          return JSON.stringify({ error: `Unknown action: ${action}` });
+      }
+    },
+  });
+}
+
+async function createSkill(input: Record<string, unknown>): Promise<string> {
+  const name = input.name as string;
+  const description = input.description as string;
+  const inputSchema = input.input_schema as Record<string, unknown> | undefined;
+  const params = input.params as Record<string, { type: string; description?: string; required?: boolean }> | undefined;
+  const handlerCode = input.handler_code as string;
+
+  if (!name || !/^[a-z0-9_]+$/.test(name)) {
+    return JSON.stringify({ error: "Invalid name. Must match [a-z0-9_]+" });
+  }
+  if (!description) {
+    return JSON.stringify({ error: "Description is required." });
+  }
+  if (!handlerCode) {
+    return JSON.stringify({ error: "handler_code is required." });
+  }
+
+  // Resolve the final input schema — accept either params shorthand or full input_schema
+  let resolvedSchema: Record<string, unknown>;
+  if (params) {
+    resolvedSchema = paramsToJsonSchema(params);
+  } else if (inputSchema) {
+    resolvedSchema = inputSchema;
+  } else {
+    return JSON.stringify({ error: "Either params or input_schema is required." });
+  }
+
+  // Check for existing tool (built-in or skill)
+  if (getTool(name)) {
+    return JSON.stringify({ error: `A tool named "${name}" already exists.` });
+  }
+
+  const destDir = join(paths.skills, name);
+
+  // Build params block for the skill config
+  const escParam = (s: string) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  let paramsLiteral = "{}";
+  if (params) {
+    const lines = Object.entries(params).map(([key, def]) => {
+      const parts = [`type: "${def.type || "string"}"`];
+      if (def.description) parts.push(`description: "${escParam(def.description)}"`);
+      if (def.required) parts.push("required: true");
+      return `    ${key}: { ${parts.join(", ")} }`;
+    });
+    paramsLiteral = `{\n${lines.join(",\n")}\n  }`;
+  } else if (inputSchema) {
+    // Convert full JSON Schema back to params shorthand for the file
+    const props = (inputSchema as any).properties || {};
+    const req = (inputSchema as any).required || [];
+    const lines = Object.entries(props).map(([key, def]: [string, any]) => {
+      const parts = [`type: "${escParam(Array.isArray(def.type) ? def.type[0] : (def.type || "string"))}"`];
+      if (def.description) parts.push(`description: "${escParam(def.description)}"`);
+      if (req.includes(key)) parts.push("required: true");
+      return `    ${key}: { ${parts.join(", ")} }`;
+    });
+    paramsLiteral = lines.length ? `{\n${lines.join(",\n")}\n  }` : "{}";
+  }
+
+  // Generate single-file handler.ts with skill config prepended
+  const esc = (s: string) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const skillHeader = `export const skill = {
+  name: "${esc(name)}",
+  description: "${esc(description)}",
+  params: ${paramsLiteral}
+};
+
+`;
+
+  const fullHandler = skillHeader + handlerCode;
+
+  // Write files
+  mkdirSync(destDir, { recursive: true });
+  writeFileSync(join(destDir, "handler.ts"), fullHandler);
+
+  // Hot-reload: dynamically import and register
+  try {
+    const handlerPath = join(destDir, "handler.ts");
+    const mod = await import(handlerPath);
+    const handler = mod.default;
+
+    if (typeof handler !== "function") {
+      return JSON.stringify({
+        error: "handler_code must export a default function.",
+        files_written: true,
+      });
+    }
+
+    registerTool({
+      definition: {
+        name,
+        description,
+        input_schema: resolvedSchema,
+      },
+      execute: handler,
+    });
+
+    logger.info(`Skill "${name}" created and registered at runtime`);
+    return JSON.stringify({
+      success: true,
+      name,
+      message: `Skill "${name}" created and available immediately.`,
+    });
+  } catch (err: any) {
+    logger.error(`Failed to hot-load skill "${name}": ${err.message}`);
+    return JSON.stringify({
+      error: `Files written but failed to load handler: ${err.message}`,
+      files_written: true,
+    });
+  }
+}
+
+function listSkills(): string {
+  if (!existsSync(paths.skills)) {
+    return JSON.stringify({ skills: [] });
+  }
+
+  let entries: string[];
+  try {
+    entries = readdirSync(paths.skills);
+  } catch {
+    return JSON.stringify({ skills: [] });
+  }
+
+  const skills: { name: string; description: string; status: string }[] = [];
+
+  for (const entry of entries) {
+    const dirPath = join(paths.skills, entry);
+    const skillMdPath = join(dirPath, "SKILL.md");
+    const handlerPath = join(dirPath, "handler.ts");
+
+    const hasHandler = existsSync(handlerPath);
+    const hasSkillMd = existsSync(skillMdPath);
+
+    if (!hasHandler && !hasSkillMd) continue;
+
+    let name = entry;
+    let description = "";
+    let status = "error";
+
+    if (hasSkillMd) {
+      const mdContent = readFileSync(skillMdPath, "utf-8");
+      const parsed = parseSkillMd(mdContent, dirPath);
+      name = parsed?.name ?? entry;
+      description = parsed?.description?.split("\n")[0] ?? "";
+      status = parsed && hasHandler ? "ok" : "error";
+    } else if (hasHandler) {
+      try {
+        const content = readFileSync(handlerPath, "utf-8");
+        const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
+        const descMatch = content.match(/description\s*:\s*["']([^"']+)["']/);
+        if (nameMatch) name = nameMatch[1];
+        if (descMatch) description = descMatch[1];
+        status = "ok";
+      } catch {
+        status = "error";
+      }
+    }
+
+    skills.push({ name, description, status });
+  }
+
+  return JSON.stringify({ skills, count: skills.length });
+}
+
+function removeSkill(input: Record<string, unknown>): string {
+  const name = input.name as string;
+  if (!name) {
+    return JSON.stringify({ error: "Skill name is required for remove." });
+  }
+
+  // Find the skill folder (folder name might differ from tool name)
+  if (!existsSync(paths.skills)) {
+    return JSON.stringify({ error: "No skills directory found." });
+  }
+
+  let entries: string[];
+  try {
+    entries = readdirSync(paths.skills);
+  } catch {
+    return JSON.stringify({ error: "Could not read skills directory." });
+  }
+
+  let targetFolder: string | null = null;
+  for (const entry of entries) {
+    const dirPath = join(paths.skills, entry);
+    const skillMdPath = join(dirPath, "SKILL.md");
+    const handlerPath = join(dirPath, "handler.ts");
+
+    if (entry === name) {
+      targetFolder = entry;
+      break;
+    }
+
+    if (existsSync(skillMdPath)) {
+      const mdContent = readFileSync(skillMdPath, "utf-8");
+      const parsed = parseSkillMd(mdContent, dirPath);
+      if (parsed?.name === name) {
+        targetFolder = entry;
+        break;
+      }
+    } else if (existsSync(handlerPath)) {
+      try {
+        const content = readFileSync(handlerPath, "utf-8");
+        const nameMatch = content.match(/name\s*:\s*["']([^"']+)["']/);
+        if (nameMatch && nameMatch[1] === name) {
+          targetFolder = entry;
+          break;
+        }
+      } catch {
+        // skip
+      }
+    }
+  }
+
+  if (!targetFolder) {
+    return JSON.stringify({ error: `Skill "${name}" not found.` });
+  }
+
+  const dirPath = join(paths.skills, targetFolder);
+  rmSync(dirPath, { recursive: true, force: true });
+  unregisterTool(name);
+
+  logger.info(`Skill "${name}" removed`);
+  return JSON.stringify({
+    success: true,
+    name,
+    message: `Skill "${name}" removed.`,
+  });
+}

package/src/tools/builtin/manage-teams.ts

@@ -0,0 +1,89 @@
+import { registerTool } from "../registry";
+import { loadTeams, getTeam, createTeam, removeTeam, type AgentTeam } from "../../agent/teams";
+
+export function registerManageTeamsTool() {
+  registerTool({
+    definition: {
+      name: "manage_teams",
+      description:
+        "Create, list, view, and remove agent teams. Teams group agents together with an optional default workflow.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "view", "remove"],
+            description: "Action to perform",
+          },
+          name: {
+            type: "string",
+            description: "Team name",
+          },
+          description: {
+            type: "string",
+            description: "Team description (for create)",
+          },
+          agents: {
+            type: "array",
+            items: { type: "string" },
+            description: "Agent names in the team (for create)",
+          },
+          default_workflow: {
+            type: "string",
+            description: "Default workflow for this team (for create)",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    async execute(input) {
+      const action = input.action as string;
+
+      switch (action) {
+        case "list": {
+          const teams = loadTeams();
+          if (teams.length === 0) return "No teams defined.";
+          return JSON.stringify(
+            teams.map((t) => ({
+              name: t.name,
+              description: t.description,
+              agents: t.agents,
+              defaultWorkflow: t.defaultWorkflow,
+            }))
+          );
+        }
+
+        case "view": {
+          const name = input.name as string;
+          if (!name) return JSON.stringify({ error: "name is required" });
+          const team = getTeam(name);
+          if (!team) return JSON.stringify({ error: `Team "${name}" not found` });
+          return JSON.stringify(team);
+        }
+
+        case "create": {
+          const name = input.name as string;
+          if (!name) return JSON.stringify({ error: "name is required" });
+          const team: AgentTeam = {
+            name,
+            description: (input.description as string) ?? "",
+            agents: (input.agents as string[]) ?? [],
+            defaultWorkflow: input.default_workflow as string | undefined,
+          };
+          const path = createTeam(team);
+          return JSON.stringify({ created: true, name, path });
+        }
+
+        case "remove": {
+          const name = input.name as string;
+          if (!name) return JSON.stringify({ error: "name is required" });
+          const removed = removeTeam(name);
+          return JSON.stringify({ removed, name });
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${action}` });
+      }
+    },
+  });
+}

package/src/tools/builtin/manage-triggers.ts

@@ -0,0 +1,94 @@
+import { registerTool } from "../registry";
+import { getDb } from "../../db/connection";
+
+export function registerManageTriggersTool() {
+  registerTool({
+    definition: {
+      name: "manage_triggers",
+      description:
+        "Create, list, and remove proactive memory triggers. Triggers fire based on memory patterns and schedule.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "remove"],
+            description: "Action to perform",
+          },
+          pattern: {
+            type: "string",
+            description: "Memory search pattern that triggers the action",
+          },
+          trigger_action: {
+            type: "string",
+            description: "What to do when the trigger fires (task for the agent)",
+          },
+          schedule: {
+            type: "string",
+            enum: ["once", "daily", "weekly", "monthly"],
+            description: "How often to check/fire (default: once)",
+          },
+          trigger_id: {
+            type: "number",
+            description: "Trigger ID (for remove)",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    async execute(input) {
+      const action = input.action as string;
+      const db = getDb();
+
+      switch (action) {
+        case "list": {
+          try {
+            const triggers = db.query(
+              "SELECT * FROM memory_triggers ORDER BY id"
+            ).all();
+            return JSON.stringify(triggers);
+          } catch {
+            return JSON.stringify({ error: "Triggers table not available" });
+          }
+        }
+
+        case "create": {
+          const pattern = input.pattern as string;
+          const triggerAction = input.trigger_action as string;
+          const schedule = (input.schedule as string) ?? "once";
+
+          if (!pattern) return JSON.stringify({ error: "pattern is required" });
+          if (!triggerAction) return JSON.stringify({ error: "trigger_action is required" });
+
+          try {
+            const result = db.prepare(
+              "INSERT INTO memory_triggers (pattern, action, schedule) VALUES (?, ?, ?)"
+            ).run(pattern, triggerAction, schedule);
+            return JSON.stringify({
+              created: true,
+              id: Number(result.lastInsertRowid),
+              pattern,
+              schedule,
+            });
+          } catch (err: any) {
+            return JSON.stringify({ error: err.message });
+          }
+        }
+
+        case "remove": {
+          const triggerId = input.trigger_id as number;
+          if (!triggerId) return JSON.stringify({ error: "trigger_id is required" });
+          try {
+            db.prepare("DELETE FROM memory_triggers WHERE id = ?").run(triggerId);
+            return JSON.stringify({ removed: true, id: triggerId });
+          } catch (err: any) {
+            return JSON.stringify({ error: err.message });
+          }
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${action}` });
+      }
+    },
+  });
+}

package/src/tools/builtin/manage-workflows.ts

@@ -0,0 +1,119 @@
+import { registerTool } from "../registry";
+import {
+  loadWorkflowDefinitions,
+  getWorkflowDefinition,
+  createWorkflowDefinition,
+  removeWorkflowDefinition,
+  type WorkflowDefinition,
+  type WorkflowStep,
+} from "../../agent/workflow";
+
+export function registerManageWorkflowsTool() {
+  registerTool({
+    definition: {
+      name: "manage_workflows",
+      description:
+        "Create, list, view, and remove multi-agent workflows. Workflows orchestrate multiple agents in a dependency graph.",
+      input_schema: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["create", "list", "view", "remove"],
+            description: "Action to perform",
+          },
+          name: {
+            type: "string",
+            description: "Workflow name",
+          },
+          description: {
+            type: "string",
+            description: "Workflow description (for create)",
+          },
+          agents: {
+            type: "array",
+            items: { type: "string" },
+            description: "Agent names used in this workflow (for create)",
+          },
+          steps: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                agent: { type: "string" },
+                task: { type: "string" },
+                dependsOn: { type: "array", items: { type: "string" } },
+                outputVar: { type: "string" },
+              },
+            },
+            description: "Workflow steps (for create)",
+          },
+        },
+        required: ["action"],
+      },
+    },
+    async execute(input) {
+      const action = input.action as string;
+
+      switch (action) {
+        case "list": {
+          const workflows = loadWorkflowDefinitions();
+          if (workflows.length === 0) return "No workflows defined.";
+          return JSON.stringify(
+            workflows.map((w) => ({
+              name: w.name,
+              description: w.description,
+              stepCount: w.steps.length,
+              agents: w.agents,
+            }))
+          );
+        }
+
+        case "view": {
+          const name = input.name as string;
+          if (!name) return JSON.stringify({ error: "name is required" });
+          const def = getWorkflowDefinition(name);
+          if (!def) return JSON.stringify({ error: `Workflow "${name}" not found` });
+          return JSON.stringify(def);
+        }
+
+        case "create": {
+          const name = input.name as string;
+          const description = (input.description as string) ?? "";
+          const agents = (input.agents as string[]) ?? [];
+          const steps = (input.steps as WorkflowStep[]) ?? [];
+
+          if (!name) return JSON.stringify({ error: "name is required" });
+          if (!steps.length) return JSON.stringify({ error: "at least one step is required" });
+
+          const def: WorkflowDefinition = {
+            name,
+            description,
+            agents,
+            steps: steps.map((s) => ({
+              name: s.name ?? "unnamed",
+              agent: s.agent ?? "main",
+              task: s.task ?? "",
+              dependsOn: s.dependsOn ?? [],
+              outputVar: s.outputVar,
+            })),
+          };
+
+          const path = createWorkflowDefinition(def);
+          return JSON.stringify({ created: true, name, path });
+        }
+
+        case "remove": {
+          const name = input.name as string;
+          if (!name) return JSON.stringify({ error: "name is required" });
+          const removed = removeWorkflowDefinition(name);
+          return JSON.stringify({ removed, name });
+        }
+
+        default:
+          return JSON.stringify({ error: `Unknown action: ${action}` });
+      }
+    },
+  });
+}

package/src/tools/builtin/memory-search.ts

@@ -0,0 +1,38 @@
+import { Database } from "bun:sqlite";
+import { registerTool } from "../registry";
+import { searchMemoryAsync } from "../../memory/engine";
+
+export function registerMemorySearchTool(db: Database) {
+  registerTool({
+    definition: {
+      name: "memory_search",
+      description:
+        "Search persistent memory for previously stored information. Use this when the user asks about something you might have saved before, or when you need to recall facts about the user.",
+      input_schema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description:
+              "Search query. Use natural language — both keyword and semantic search are used.",
+          },
+        },
+        required: ["query"],
+      },
+    },
+    execute: async (input) => {
+      const query = input.query as string;
+      const results = await searchMemoryAsync(db, query, 5);
+
+      if (results.length === 0) {
+        return "No relevant memories found.";
+      }
+
+      const formatted = results
+        .map((r, i) => `[${i + 1}] ${r.content}`)
+        .join("\n\n");
+
+      return `Found ${results.length} relevant memories:\n\n${formatted}`;
+    },
+  });
+}

package/src/tools/builtin/memory-write.ts

@@ -0,0 +1,30 @@
+import { registerTool } from "../registry";
+import { writeAndIndexMemory } from "../../memory/engine";
+import { getDb } from "../../db/connection";
+
+export function registerMemoryWriteTool() {
+  registerTool({
+    definition: {
+      name: "memory_write",
+      description:
+        "Save an important fact or piece of information to persistent memory. Use this when the user shares personal details, preferences, or any information worth remembering across conversations.",
+      input_schema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description:
+              "The information to remember. Be specific and factual. Example: 'User's name is Thomas. He lives in Berlin.'",
+          },
+        },
+        required: ["content"],
+      },
+    },
+    execute: async (input) => {
+      const content = input.content as string;
+      const db = getDb();
+      await writeAndIndexMemory(db, content);
+      return `Saved to memory: "${content.slice(0, 100)}"`;
+    },
+  });
+}