zubo 0.1.0

package/src/setup.ts

@@ -0,0 +1,413 @@
+import { paths, ensureDirectories } from "./config/paths";
+import { saveConfig } from "./config/loader";
+import { configSchema } from "./config/schema";
+import type { ProviderConfig } from "./config/schema";
+import { getDb } from "./db/connection";
+import { runMigrations } from "./db/migrations";
+import { logger } from "./util/logger";
+import { existsSync } from "fs";
+import { installBuiltinSkills } from "./tools/skill-installer";
+
+async function prompt(question: string): Promise<string> {
+  process.stdout.write(question);
+  for await (const line of console) {
+    return line.trim();
+  }
+  return "";
+}
+
+interface ProviderOption {
+  key: string;
+  label: string;
+  setup: () => Promise<{ name: string; config: ProviderConfig }>;
+}
+
+const PROVIDER_OPTIONS: ProviderOption[] = [
+  {
+    key: "1",
+    label: "Anthropic (Claude)",
+    setup: async () => {
+      const apiKey = await prompt("Anthropic API key (sk-ant-...): ");
+      if (!apiKey.startsWith("sk-ant-")) {
+        console.log("Warning: Key doesn't start with 'sk-ant-'. Proceeding anyway.");
+      }
+      const model = await prompt("Model [claude-sonnet-4-5-20250929]: ");
+      return {
+        name: "anthropic",
+        config: { apiKey, model: model || "claude-sonnet-4-5-20250929" },
+      };
+    },
+  },
+  {
+    key: "2",
+    label: "OpenAI (GPT)",
+    setup: async () => {
+      const apiKey = await prompt("OpenAI API key (sk-...): ");
+      const model = await prompt("Model [gpt-4.1]: ");
+      return {
+        name: "openai",
+        config: { apiKey, model: model || "gpt-4.1" },
+      };
+    },
+  },
+  {
+    key: "3",
+    label: "Ollama (local)",
+    setup: async () => {
+      const baseUrl = await prompt("Ollama URL [http://localhost:11434/v1]: ");
+      const model = await prompt("Model [llama3.3]: ");
+      return {
+        name: "ollama",
+        config: {
+          baseUrl: baseUrl || "http://localhost:11434/v1",
+          apiKey: "ollama",
+          model: model || "llama3.3",
+          streaming: false,
+        },
+      };
+    },
+  },
+  {
+    key: "4",
+    label: "Groq",
+    setup: async () => {
+      const apiKey = await prompt("Groq API key (gsk_...): ");
+      const model = await prompt("Model [llama-3.3-70b-versatile]: ");
+      return {
+        name: "groq",
+        config: { apiKey, model: model || "llama-3.3-70b-versatile" },
+      };
+    },
+  },
+  {
+    key: "5",
+    label: "Together AI",
+    setup: async () => {
+      const apiKey = await prompt("Together API key: ");
+      const model = await prompt("Model [meta-llama/Llama-3.3-70B-Instruct-Turbo]: ");
+      return {
+        name: "together",
+        config: {
+          apiKey,
+          baseUrl: "https://api.together.xyz/v1",
+          model: model || "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        },
+      };
+    },
+  },
+  {
+    key: "6",
+    label: "OpenRouter",
+    setup: async () => {
+      const apiKey = await prompt("OpenRouter API key: ");
+      const model = await prompt("Model [anthropic/claude-sonnet-4-5]: ");
+      return {
+        name: "openrouter",
+        config: {
+          apiKey,
+          baseUrl: "https://openrouter.ai/api/v1",
+          model: model || "anthropic/claude-sonnet-4-5",
+        },
+      };
+    },
+  },
+  {
+    key: "7",
+    label: "DeepSeek",
+    setup: async () => {
+      const apiKey = await prompt("DeepSeek API key: ");
+      const model = await prompt("Model [deepseek-chat]: ");
+      return {
+        name: "deepseek",
+        config: {
+          apiKey,
+          baseUrl: "https://api.deepseek.com/v1",
+          model: model || "deepseek-chat",
+        },
+      };
+    },
+  },
+  {
+    key: "8",
+    label: "xAI (Grok)",
+    setup: async () => {
+      const apiKey = await prompt("xAI API key: ");
+      const model = await prompt("Model [grok-4.1-fast]: ");
+      return {
+        name: "xai",
+        config: {
+          apiKey,
+          baseUrl: "https://api.x.ai/v1",
+          model: model || "grok-4.1-fast",
+        },
+      };
+    },
+  },
+  {
+    key: "9",
+    label: "Fireworks AI",
+    setup: async () => {
+      const apiKey = await prompt("Fireworks API key: ");
+      const model = await prompt("Model [accounts/fireworks/models/llama-v3p3-70b-instruct]: ");
+      return {
+        name: "fireworks",
+        config: {
+          apiKey,
+          baseUrl: "https://api.fireworks.ai/inference/v1",
+          model: model || "accounts/fireworks/models/llama-v3p3-70b-instruct",
+        },
+      };
+    },
+  },
+  {
+    key: "10",
+    label: "Cerebras",
+    setup: async () => {
+      const apiKey = await prompt("Cerebras API key: ");
+      const model = await prompt("Model [llama-3.3-70b]: ");
+      return {
+        name: "cerebras",
+        config: {
+          apiKey,
+          baseUrl: "https://api.cerebras.ai/v1",
+          model: model || "llama-3.3-70b",
+        },
+      };
+    },
+  },
+  {
+    key: "11",
+    label: "LM Studio (local)",
+    setup: async () => {
+      const baseUrl = await prompt("LM Studio URL [http://localhost:1234/v1]: ");
+      const model = await prompt("Model name: ");
+      return {
+        name: "lmstudio",
+        config: {
+          baseUrl: baseUrl || "http://localhost:1234/v1",
+          apiKey: "lm-studio",
+          model: model || "default",
+        },
+      };
+    },
+  },
+  {
+    key: "12",
+    label: "Other (OpenAI-compatible)",
+    setup: async () => {
+      const name = await prompt("Provider name: ");
+      const baseUrl = await prompt("Base URL (e.g. https://api.example.com/v1): ");
+      const apiKey = await prompt("API key (or 'none'): ");
+      const model = await prompt("Model name: ");
+      return {
+        name: name || "custom",
+        config: {
+          baseUrl,
+          apiKey: apiKey === "none" ? undefined : apiKey,
+          model: model || "default",
+        },
+      };
+    },
+  },
+];
+
+function printProviderMenu() {
+  for (const opt of PROVIDER_OPTIONS) {
+    console.log(`  ${opt.key}. ${opt.label}`);
+  }
+  console.log("");
+}
+
+async function pickProvider(): Promise<{ name: string; config: ProviderConfig } | null> {
+  const maxKey = PROVIDER_OPTIONS.length;
+  const choice = await prompt(`Provider [1-${maxKey}]: `);
+  const option = PROVIDER_OPTIONS.find((o) => o.key === choice);
+  if (!option) return null;
+  console.log("");
+  return option.setup();
+}
+
+async function setupProvider(): Promise<{
+  providers: Record<string, ProviderConfig>;
+  activeProvider: string;
+  anthropicApiKey?: string;
+}> {
+  console.log("Choose your LLM provider:\n");
+  printProviderMenu();
+
+  const result = await pickProvider();
+  if (!result) {
+    console.log("Invalid choice. Defaulting to Anthropic.\n");
+    const apiKey = await prompt("Anthropic API key (sk-ant-...): ");
+    const model = "claude-sonnet-4-5-20250929";
+    return {
+      providers: { anthropic: { apiKey, model } },
+      activeProvider: "anthropic",
+      anthropicApiKey: apiKey,
+    };
+  }
+
+  const providers: Record<string, ProviderConfig> = {
+    [result.name]: result.config,
+  };
+  const anthropicApiKey =
+    result.name === "anthropic" ? result.config.apiKey : undefined;
+
+  console.log(`\n✓ ${result.name} configured (${result.config.model})`);
+
+  // Offer to add a fallback
+  const addFallback = await prompt("\nAdd a fallback provider? (y/N): ");
+  if (addFallback.toLowerCase() === "y") {
+    console.log("\nFallback provider:\n");
+    printProviderMenu();
+    const fb = await pickProvider();
+    if (fb) {
+      providers[fb.name] = fb.config;
+      console.log(`✓ ${fb.name} added as fallback (${fb.config.model})`);
+    }
+  }
+
+  return { providers, activeProvider: result.name, anthropicApiKey };
+}
+
+async function setupChannels(): Promise<{
+  channels: Record<string, any>;
+  telegramBotToken?: string;
+}> {
+  console.log("Which channels do you want to enable?\n");
+  console.log("  1. Telegram");
+  console.log("  2. Discord");
+  console.log("  3. WebChat (local browser UI)");
+  console.log("");
+  console.log("Enter numbers separated by commas, e.g. 1,3\n");
+
+  const choices = await prompt("Channels [1]: ");
+  const selected = choices
+    ? choices.split(",").map((s) => s.trim())
+    : ["1"];
+
+  const channels: Record<string, any> = {};
+  let telegramBotToken: string | undefined;
+
+  if (selected.includes("1")) {
+    console.log("\nTo create a Telegram bot:");
+    console.log("  1. Open Telegram and message @BotFather");
+    console.log("  2. Send /newbot and follow the prompts");
+    console.log("  3. Copy the bot token\n");
+    const token = await prompt("Telegram bot token: ");
+    channels.telegram = { enabled: true, botToken: token, allowedUsers: [] };
+    telegramBotToken = token;
+    console.log("✓ Telegram configured");
+  }
+
+  if (selected.includes("2")) {
+    console.log("\nTo create a Discord bot:");
+    console.log("  1. Go to https://discord.com/developers/applications");
+    console.log("  2. Create an application → Bot → copy token");
+    console.log("  3. Enable MESSAGE CONTENT intent");
+    console.log("  4. Invite bot with messages scope\n");
+    const token = await prompt("Discord bot token: ");
+    channels.discord = { enabled: true, botToken: token, allowedUsers: [] };
+    console.log("✓ Discord configured");
+  }
+
+  if (selected.includes("3")) {
+    const portStr = await prompt("\nWebChat port [auto]: ");
+    const port = parseInt(portStr, 10) || 0;
+    channels.webchat = { enabled: true, port };
+    console.log(`✓ WebChat configured${port ? ` on port ${port}` : " (auto port)"}`);
+  }
+
+  if (Object.keys(channels).length === 0) {
+    console.log("\nNo channels selected. Defaulting to WebChat (auto port).");
+    channels.webchat = { enabled: true, port: 0 };
+  }
+
+  return { channels, telegramBotToken };
+}
+
+export async function runSetup() {
+  console.log("\n  Zubo Setup Wizard\n");
+  console.log("This will configure your Zubo agent.\n");
+
+  // 1. LLM provider
+  const { providers, activeProvider, anthropicApiKey } = await setupProvider();
+
+  // Build failover list from extra providers
+  const failover = Object.keys(providers).filter((k) => k !== activeProvider);
+
+  // 2. Channels
+  const { channels, telegramBotToken } = await setupChannels();
+
+  // 3. Create directory tree
+  console.log("\nCreating ~/.zubo/ directory tree...");
+  ensureDirectories();
+
+  // 4. Write config
+  const config = configSchema.parse({
+    // Legacy compat
+    anthropicApiKey,
+    model: providers[activeProvider].model,
+    telegramBotToken,
+    telegramAllowedUsers: [],
+
+    // New provider system
+    providers,
+    activeProvider,
+    failover: failover.length ? failover : undefined,
+
+    // Channels
+    channels,
+  });
+  await saveConfig(config);
+  console.log(`Config saved to ${paths.config}`);
+
+  // 5. Init SQLite DB
+  console.log("Initializing database...");
+  const db = getDb();
+  runMigrations(db);
+  db.close();
+  console.log(`Database created at ${paths.db}`);
+
+  // 6. Create initial MEMORY.md
+  if (!existsSync(paths.memoryFile)) {
+    await Bun.write(
+      paths.memoryFile,
+      `# Zubo Memory\n\nThis file stores persistent memories about the user.\n`
+    );
+    console.log(`Created ${paths.memoryFile}`);
+  }
+
+  // 7. Create default SYSTEM.md
+  if (!existsSync(paths.systemPrompt)) {
+    await Bun.write(
+      paths.systemPrompt,
+      `You are Zubo, a personal AI agent. You are helpful, proactive, and have a persistent memory.
+
+## Your capabilities
+- You remember things about the user across conversations using your memory tools.
+- You can check the current date and time.
+- You are conversational and friendly, but concise.
+- When the user tells you something personal (name, preferences, facts about their life), proactively save it to memory.
+- When answering questions that might relate to stored memories, search your memory first.
+
+## Guidelines
+- Be concise. Don't over-explain unless asked.
+- Use memory_write to save important facts the user shares.
+- Use memory_search to recall previously stored information.
+- If you're unsure about something, say so.
+`
+    );
+    console.log(`Created ${paths.systemPrompt}`);
+  }
+
+  // 8. Install built-in skills
+  const installed = installBuiltinSkills(paths.skills);
+  if (installed.length) {
+    console.log(`Installed ${installed.length} built-in skills: ${installed.join(", ")}`);
+  } else {
+    console.log("Built-in skills already installed.");
+  }
+
+  console.log("\nSetup complete! Run 'zubo start' to launch Zubo.\n");
+}

package/src/skills.ts

@@ -0,0 +1,293 @@
+import { readdirSync, readFileSync, existsSync, rmSync } from "fs";
+import { join } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+import { paths } from "./config/paths";
+import { parseSkillMd, parseSkillExport } from "./tools/skill-loader";
+import { getBuiltinSkillNames, reinstallBuiltinSkill } from "./tools/skill-installer";
+
+async function prompt(question: string): Promise<string> {
+  process.stdout.write(question);
+  for await (const line of console) {
+    return line.trim();
+  }
+  return "";
+}
+
+function getInstalledSkills(): { name: string; status: string; description: string; folder: string }[] {
+  if (!existsSync(paths.skills)) return [];
+
+  let entries: string[];
+  try {
+    entries = readdirSync(paths.skills);
+  } catch {
+    return [];
+  }
+
+  const skills: { name: string; status: string; description: string; folder: 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 desc = "—";
+    let status = "error";
+
+    if (hasSkillMd) {
+      const mdContent = readFileSync(skillMdPath, "utf-8");
+      const parsed = parseSkillMd(mdContent, dirPath);
+      if (parsed) {
+        name = parsed.name;
+        desc = parsed.description?.split("\n")[0] ?? "—";
+        status = hasHandler ? "ok" : "error";
+      }
+    } else if (hasHandler) {
+      // Single-file skill: try to read the exported skill config via regex
+      try {
+        const handlerContent = readFileSync(handlerPath, "utf-8");
+        const nameMatch = handlerContent.match(/name\s*:\s*["']([^"']+)["']/);
+        const descMatch = handlerContent.match(/description\s*:\s*["']([^"']+)["']/);
+        if (nameMatch) name = nameMatch[1];
+        if (descMatch) desc = descMatch[1];
+        status = "ok";
+      } catch {
+        status = "error";
+      }
+    }
+
+    skills.push({ name, status, description: desc.slice(0, 60), folder: entry });
+  }
+
+  return skills;
+}
+
+function listSkills() {
+  console.log("\n  Zubo Skills\n");
+
+  const skills = getInstalledSkills();
+
+  if (skills.length === 0) {
+    console.log("  No skills installed.\n");
+    console.log("  Drop skill folders into ~/.zubo/workspace/skills/");
+    console.log("  Each folder needs a handler.ts file\n");
+    return;
+  }
+
+  const nameW = Math.max(10, ...skills.map((s) => s.name.length)) + 2;
+  const header = `  ${"Name".padEnd(nameW)}${"Status".padEnd(10)}Description`;
+  console.log(header);
+  console.log("  " + "-".repeat(header.length - 2));
+
+  for (const s of skills) {
+    const statusIcon = s.status === "ok" ? "ok" : "err";
+    console.log(`  ${s.name.padEnd(nameW)}${statusIcon.padEnd(10)}${s.description}`);
+  }
+
+  console.log(`\n  ${skills.length} skill(s) installed.\n`);
+}
+
+async function createSkillWizard() {
+  console.log("\n  Create New Skill\n");
+
+  const name = await prompt("  Tool name (lowercase, underscores only): ");
+  if (!name || !/^[a-z0-9_]+$/.test(name)) {
+    console.log("  Invalid name. Must match [a-z0-9_]+\n");
+    return;
+  }
+
+  const destDir = join(paths.skills, name);
+  if (existsSync(destDir)) {
+    console.log(`  Skill "${name}" already exists.\n`);
+    return;
+  }
+
+  const description = await prompt("  Description: ");
+  if (!description) {
+    console.log("  Description is required.\n");
+    return;
+  }
+
+  // Collect parameters
+  const params: Record<string, { type: string; description: string; required?: boolean }> = {};
+
+  console.log("\n  Add parameters (press Enter with empty name to finish):\n");
+
+  while (true) {
+    const paramName = await prompt("    Parameter name: ");
+    if (!paramName) break;
+
+    const paramType = await prompt("    Type [string]: ");
+    const paramDesc = await prompt("    Description: ");
+    const paramReq = await prompt("    Required? (y/N): ");
+
+    params[paramName] = {
+      type: paramType || "string",
+      description: paramDesc || "",
+    };
+    if (paramReq.toLowerCase() === "y") {
+      params[paramName].required = true;
+    }
+    console.log("");
+  }
+
+  // Build params block for the skill config
+  const paramEntries = Object.entries(params);
+  let paramsBlock = "{}";
+  if (paramEntries.length > 0) {
+    const paramLines = paramEntries.map(([p, def]) => {
+      const parts = [`type: "${def.type}"`];
+      if (def.description) parts.push(`description: "${def.description}"`);
+      if (def.required) parts.push("required: true");
+      return `    ${p}: { ${parts.join(", ")} }`;
+    });
+    paramsBlock = `{\n${paramLines.join(",\n")}\n  }`;
+  }
+
+  // Generate single-file handler.ts
+  const extractLines = paramEntries
+    .map(([p, def]) => `  const ${p} = input.${p} as ${def.type === "number" ? "number" : "string"};`)
+    .join("\n");
+
+  const handlerTs = `export const skill = {
+  name: "${name}",
+  description: "${description}",
+  params: ${paramsBlock}
+};
+
+export default async function (input: Record<string, unknown>): Promise<string> {
+${extractLines || "  // Access parameters from input"}
+
+  // TODO: Implement your skill logic here
+
+  return JSON.stringify({ result: "Not yet implemented" });
+}
+`;
+
+  // Write files
+  mkdirSync(destDir, { recursive: true });
+  writeFileSync(join(destDir, "handler.ts"), handlerTs);
+
+  console.log(`\n  Skill created at ~/.zubo/workspace/skills/${name}/`);
+  console.log("  Files:");
+  console.log(`    handler.ts  — skill config + implementation`);
+  console.log(`\n  Restart Zubo to load the new skill.\n`);
+}
+
+async function reinstallBuiltins() {
+  console.log("\n  Reinstall Built-in Skills\n");
+
+  const builtinNames = getBuiltinSkillNames();
+  if (builtinNames.length === 0) {
+    console.log("  No built-in skills found.\n");
+    return;
+  }
+
+  console.log("  Available built-in skills:");
+  for (const name of builtinNames) {
+    const destDir = join(paths.skills, name);
+    const status = existsSync(destDir) ? "(installed)" : "(missing)";
+    console.log(`    - ${name} ${status}`);
+  }
+
+  const confirm = await prompt("\n  This will overwrite existing copies. Continue? (y/N): ");
+  if (confirm.toLowerCase() !== "y") {
+    console.log("  Cancelled.\n");
+    return;
+  }
+
+  let count = 0;
+  for (const name of builtinNames) {
+    if (reinstallBuiltinSkill(paths.skills, name)) {
+      count++;
+    }
+  }
+
+  console.log(`\n  Reinstalled ${count} built-in skill(s).\n`);
+}
+
+async function removeSkill() {
+  console.log("\n  Remove a Skill\n");
+
+  const skills = getInstalledSkills();
+  if (skills.length === 0) {
+    console.log("  No skills installed.\n");
+    return;
+  }
+
+  for (let i = 0; i < skills.length; i++) {
+    console.log(`  ${i + 1}. ${skills[i].name}`);
+  }
+
+  const choice = await prompt(`\n  Remove which skill? [1-${skills.length}]: `);
+  const idx = parseInt(choice, 10) - 1;
+  if (isNaN(idx) || idx < 0 || idx >= skills.length) {
+    console.log("  Invalid choice.\n");
+    return;
+  }
+
+  const skill = skills[idx];
+  const confirm = await prompt(`  Delete "${skill.name}"? This cannot be undone. (y/N): `);
+  if (confirm.toLowerCase() !== "y") {
+    console.log("  Cancelled.\n");
+    return;
+  }
+
+  const dirPath = join(paths.skills, skill.folder);
+  rmSync(dirPath, { recursive: true, force: true });
+  console.log(`\n  Removed "${skill.name}".\n`);
+}
+
+async function showMenu() {
+  console.log("\n  Zubo Skills\n");
+  console.log("  1. List installed skills");
+  console.log("  2. Create new skill");
+  console.log("  3. Reinstall built-in skills");
+  console.log("  4. Remove a skill");
+  console.log("");
+
+  const choice = await prompt("  Choice [1-4]: ");
+
+  switch (choice) {
+    case "1":
+      listSkills();
+      break;
+    case "2":
+      await createSkillWizard();
+      break;
+    case "3":
+      await reinstallBuiltins();
+      break;
+    case "4":
+      await removeSkill();
+      break;
+    default:
+      console.log("  Invalid choice.\n");
+  }
+}
+
+export async function runSkillsCommand(args: string[] = []) {
+  const sub = args[0];
+
+  switch (sub) {
+    case "list":
+      listSkills();
+      break;
+    case "new":
+      await createSkillWizard();
+      break;
+    case "reinstall":
+      await reinstallBuiltins();
+      break;
+    case "remove":
+      await removeSkill();
+      break;
+    default:
+      await showMenu();
+  }
+}