zubo 0.1.0

package/src/index.ts

@@ -0,0 +1,261 @@
+#!/usr/bin/env bun
+export {};
+
+const command = process.argv[2];
+
+switch (command) {
+  case "setup": {
+    const { runSetup } = await import("./setup");
+    await runSetup();
+    break;
+  }
+  case "start": {
+    const isDaemon = process.argv.includes("--daemon");
+    const { startZubo } = await import("./start");
+    await startZubo(isDaemon);
+    break;
+  }
+  case "stop": {
+    const { stopDaemon } = await import("./start");
+    stopDaemon();
+    break;
+  }
+  case "status": {
+    const { showStatus } = await import("./status");
+    showStatus();
+    break;
+  }
+  case "logs": {
+    const follow = process.argv.includes("--follow") || process.argv.includes("-f");
+    const { showLogs } = await import("./logs");
+    await showLogs(follow);
+    break;
+  }
+  case "model": {
+    const { runModelCommand } = await import("./model");
+    runModelCommand(process.argv.slice(3));
+    break;
+  }
+  case "skills": {
+    const { runSkillsCommand } = await import("./skills");
+    await runSkillsCommand(process.argv.slice(3));
+    break;
+  }
+  case "install": {
+    const skillName = process.argv[3];
+    if (!skillName) {
+      console.log("Usage: zubo install <skill-name>");
+      process.exit(1);
+    }
+    const { handleRegistryInstall } = await import("./registry/cli");
+    await handleRegistryInstall(skillName);
+    break;
+  }
+  case "search": {
+    const query = process.argv.slice(3).join(" ");
+    if (!query) {
+      console.log("Usage: zubo search <query>");
+      process.exit(1);
+    }
+    const { handleRegistrySearch } = await import("./registry/cli");
+    await handleRegistrySearch(query);
+    break;
+  }
+  case "publish": {
+    const pubName = process.argv[3] ?? "";
+    const { handleRegistryPublish } = await import("./registry/cli");
+    await handleRegistryPublish(pubName);
+    break;
+  }
+  case "auth": {
+    const authAction = process.argv[3];
+    const { getDb } = await import("./db/connection");
+    const { runMigrations } = await import("./db/migrations");
+    const { initAuth, createApiKey, listApiKeys } = await import("./util/auth");
+    const authDb = getDb();
+    runMigrations(authDb);
+    initAuth(authDb);
+
+    if (authAction === "create-key") {
+      const label = process.argv[4] ?? "default";
+      const result = createApiKey(authDb, label);
+      console.log(`API key created (id: ${result.id}, label: ${label}):`);
+      console.log(`  ${result.key}`);
+      console.log("\nStore this key securely — it cannot be retrieved again.");
+    } else if (authAction === "list-keys") {
+      const keys = listApiKeys(authDb);
+      if (keys.length === 0) {
+        console.log("No API keys found. Create one with: zubo auth create-key [label]");
+      } else {
+        console.log("API Keys:");
+        for (const k of keys) {
+          console.log(`  #${k.id}  ${k.label || "(no label)"}  created: ${k.created_at}  last used: ${k.last_used_at ?? "never"}`);
+        }
+      }
+    } else if (authAction === "delete-key") {
+      const { deleteApiKey } = await import("./util/auth");
+      const keyId = parseInt(process.argv[4] ?? "", 10);
+      if (isNaN(keyId)) {
+        console.log("Usage: zubo auth delete-key <id>");
+        process.exit(1);
+      }
+      const deleted = deleteApiKey(authDb, keyId);
+      console.log(deleted ? `API key #${keyId} deleted.` : `API key #${keyId} not found.`);
+    } else {
+      console.log("Usage: zubo auth <command>\n");
+      console.log("Commands:");
+      console.log("  create-key [label]   Create a new API key");
+      console.log("  list-keys            List all API keys");
+      console.log("  delete-key <id>      Delete an API key");
+    }
+    break;
+  }
+  case "config": {
+    const configAction = process.argv[3];
+    if (configAction === "set") {
+      const key = process.argv[4];
+      const value = process.argv[5];
+      if (!key || value === undefined) {
+        console.log("Usage: zubo config set <key> <value>");
+        console.log("\nExamples:");
+        console.log("  zubo config set heartbeatMinutes 60");
+        console.log("  zubo config set maxTurns 100");
+        console.log("  zubo config set activeProvider ollama");
+        console.log("  zubo config set model llama3.3");
+        console.log("  zubo config set auth.enabled true");
+        console.log("  zubo config set rateLimit.chatPerMinute 30");
+        process.exit(1);
+      }
+      const { readFileSync, writeFileSync } = await import("fs");
+      const { paths: cfgPaths } = await import("./config/paths");
+      try {
+        const config = JSON.parse(readFileSync(cfgPaths.config, "utf-8"));
+        // Support dotted keys (e.g. auth.enabled, rateLimit.chatPerMinute)
+        const keys = key.split(".");
+        let target = config;
+        for (let i = 0; i < keys.length - 1; i++) {
+          if (!target[keys[i]] || typeof target[keys[i]] !== "object") {
+            target[keys[i]] = {};
+          }
+          target = target[keys[i]];
+        }
+        const finalKey = keys[keys.length - 1];
+        // Parse value types
+        let parsed: any = value;
+        if (value === "true") parsed = true;
+        else if (value === "false") parsed = false;
+        else if (/^\d+$/.test(value)) parsed = parseInt(value, 10);
+        else if (/^\d+\.\d+$/.test(value)) parsed = parseFloat(value);
+
+        target[finalKey] = parsed;
+        writeFileSync(cfgPaths.config, JSON.stringify(config, null, 2) + "\n");
+        console.log(`Set ${key} = ${JSON.stringify(parsed)}`);
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else if (configAction === "get") {
+      const key = process.argv[4];
+      const { readFileSync } = await import("fs");
+      const { paths: cfgPaths } = await import("./config/paths");
+      try {
+        const config = JSON.parse(readFileSync(cfgPaths.config, "utf-8"));
+        if (!key) {
+          // Print full config (mask sensitive values)
+          const masked = { ...config };
+          if (masked.anthropicApiKey) masked.anthropicApiKey = "***";
+          if (masked.providers) {
+            for (const p of Object.values(masked.providers) as any[]) {
+              if (p.apiKey) p.apiKey = "***";
+            }
+          }
+          console.log(JSON.stringify(masked, null, 2));
+        } else {
+          const keys = key.split(".");
+          let val: any = config;
+          for (const k of keys) val = val?.[k];
+          console.log(val !== undefined ? JSON.stringify(val) : "(not set)");
+        }
+      } catch (err: any) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      console.log("Usage: zubo config <command>\n");
+      console.log("Commands:");
+      console.log("  set <key> <value>   Set a config value");
+      console.log("  get [key]           Get a config value (or all if no key)");
+    }
+    break;
+  }
+  case "export": {
+    const { getDb } = await import("./db/connection");
+    const { runMigrations } = await import("./db/migrations");
+    const { exportDatabase, backupDatabase, getDbStats, getDbSizeBytes } = await import("./db/export");
+    const { paths: exportPaths } = await import("./config/paths");
+    const exportDb = getDb();
+    runMigrations(exportDb);
+
+    const format = process.argv.includes("--format") ? process.argv[process.argv.indexOf("--format") + 1] : "json";
+    const outputIdx = process.argv.indexOf("--output");
+    const output = outputIdx !== -1 ? process.argv[outputIdx + 1] : undefined;
+
+    if (format === "sqlite") {
+      const backupDir = output ?? process.cwd();
+      const backupPath = backupDatabase(exportPaths.db, backupDir);
+      console.log(`SQLite backup created: ${backupPath}`);
+    } else {
+      const outputPath = output ?? `zubo-export-${new Date().toISOString().replace(/[:.]/g, "-")}.json`;
+      exportDatabase(exportDb, outputPath);
+      const stats = getDbStats(exportDb);
+      const totalRows = Object.values(stats.tables).reduce((a, b) => a + b, 0);
+      console.log(`Exported ${totalRows} rows to ${outputPath}`);
+    }
+    break;
+  }
+  case "import": {
+    const importPath = process.argv[3];
+    if (!importPath) {
+      console.log("Usage: zubo import <path>");
+      process.exit(1);
+    }
+    const { getDb } = await import("./db/connection");
+    const { runMigrations } = await import("./db/migrations");
+    const { importDatabase } = await import("./db/export");
+    const importDb = getDb();
+    runMigrations(importDb);
+    const result = importDatabase(importDb, importPath);
+    console.log(`Imported ${result.imported} rows (${result.skipped} skipped)`);
+    break;
+  }
+  default:
+    console.log("Usage: zubo <command>\n");
+    console.log("Commands:");
+    console.log("  setup              Configure Zubo (API keys, Telegram token)");
+    console.log("  start              Start the Zubo agent");
+    console.log("  start --daemon     Start in background");
+    console.log("  stop               Stop the background daemon");
+    console.log("  status             Show config and runtime status");
+    console.log("  logs               Show last 50 log lines");
+    console.log("  logs --follow      Stream logs live");
+    console.log("  model              Show active LLM provider/model");
+    console.log("  model <p/m>        Switch provider/model (e.g. ollama/llama3.3)");
+    console.log("  model --list       List all configured providers");
+    console.log("  skills             Manage skills (interactive menu)");
+    console.log("  skills list        List installed skills");
+    console.log("  skills new         Create a new skill");
+    console.log("  skills reinstall   Reinstall built-in skills");
+    console.log("  skills remove      Remove a skill");
+    console.log("  install <skill>    Install a skill from the registry");
+    console.log("  search <query>     Search the skill registry");
+    console.log("  publish            How to publish a skill");
+    console.log("  auth create-key    Create an API key");
+    console.log("  auth list-keys     List all API keys");
+    console.log("  auth delete-key    Delete an API key");
+    console.log("  config set <k> <v> Set a config value");
+    console.log("  config get [key]   Show config value(s)");
+    console.log("  export             Export database as JSON");
+    console.log("  export --format sqlite  Backup as SQLite file");
+    console.log("  import <path>      Import data from JSON export");
+    process.exit(1);
+}

package/src/llm/claude.ts

@@ -0,0 +1,193 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type {
+  LlmProvider,
+  LlmRequest,
+  LlmResponse,
+  LlmContentBlock,
+  LlmStreamEvent,
+} from "./provider";
+import { logger } from "../util/logger";
+
+export class ClaudeProvider implements LlmProvider {
+  providerName = "anthropic";
+  model: string;
+  contextWindow = 200_000;
+  private client: Anthropic;
+
+  constructor(apiKey: string, model: string) {
+    this.client = new Anthropic({
+      apiKey,
+      defaultHeaders: { "anthropic-beta": "prompt-caching-2024-07-31" },
+    });
+    this.model = model;
+  }
+
+  async chat(request: LlmRequest): Promise<LlmResponse> {
+    logger.debug("Claude request", {
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+    });
+
+    const tools = request.tools?.length
+      ? request.tools.map((t, i, arr) =>
+          i === arr.length - 1
+            ? { ...t, cache_control: { type: "ephemeral" as const } }
+            : t,
+        )
+      : undefined;
+
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: request.maxTokens ?? 4096,
+      system: [
+        {
+          type: "text" as const,
+          text: request.system,
+          cache_control: { type: "ephemeral" as const },
+        },
+      ],
+      messages: request.messages as any,
+      tools: tools as any,
+    });
+
+    const content: LlmContentBlock[] = response.content.map((block: any) => {
+      if (block.type === "text") {
+        return { type: "text" as const, text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use" as const,
+          id: block.id,
+          name: block.name,
+          input: block.input,
+        };
+      }
+      return block;
+    });
+
+    const apiUsage = response.usage as any;
+
+    return {
+      content,
+      stopReason: response.stop_reason ?? "end_turn",
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheCreationTokens: apiUsage.cache_creation_input_tokens ?? undefined,
+        cacheReadTokens: apiUsage.cache_read_input_tokens ?? undefined,
+      },
+    };
+  }
+
+  async *chatStream(request: LlmRequest): AsyncIterable<LlmStreamEvent> {
+    logger.debug("Claude stream request", {
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+    });
+
+    const tools = request.tools?.length
+      ? request.tools.map((t, i, arr) =>
+          i === arr.length - 1
+            ? { ...t, cache_control: { type: "ephemeral" as const } }
+            : t,
+        )
+      : undefined;
+
+    const params: any = {
+      model: this.model,
+      max_tokens: request.maxTokens ?? 4096,
+      system: [
+        {
+          type: "text" as const,
+          text: request.system,
+          cache_control: { type: "ephemeral" as const },
+        },
+      ],
+      messages: request.messages as any,
+    };
+    if (tools) {
+      params.tools = tools as any;
+    }
+
+    const stream = this.client.messages.stream(params);
+
+    // Collect full response for the final message_done event
+    const contentBlocks: LlmContentBlock[] = [];
+    let currentToolId = "";
+    let currentToolName = "";
+    let currentToolJson = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let stopReason = "end_turn";
+
+    for await (const event of stream) {
+      if (event.type === "message_start") {
+        const msg = (event as any).message;
+        if (msg?.usage) {
+          inputTokens = msg.usage.input_tokens ?? 0;
+        }
+      } else if (event.type === "message_delta") {
+        const delta = (event as any).delta;
+        if (delta?.stop_reason) stopReason = delta.stop_reason;
+        const usage = (event as any).usage;
+        if (usage?.output_tokens) outputTokens = usage.output_tokens;
+      } else if (event.type === "content_block_start") {
+        const block = (event as any).content_block;
+        if (block?.type === "tool_use") {
+          currentToolId = block.id;
+          currentToolName = block.name;
+          currentToolJson = "";
+          yield { type: "tool_use_start", id: block.id, name: block.name };
+        }
+      } else if (event.type === "content_block_delta") {
+        const delta = (event as any).delta;
+        if (delta?.type === "text_delta" && delta.text) {
+          yield { type: "text_delta", text: delta.text };
+        } else if (delta?.type === "input_json_delta" && delta.partial_json) {
+          currentToolJson += delta.partial_json;
+          yield { type: "tool_use_delta", id: currentToolId, json: delta.partial_json };
+        }
+      } else if (event.type === "content_block_stop") {
+        if (currentToolId) {
+          let input: Record<string, unknown> = {};
+          try { input = JSON.parse(currentToolJson); } catch (err: any) { logger.warn("Failed to parse tool input JSON", { error: (err as Error).message }); }
+          contentBlocks.push({
+            type: "tool_use",
+            id: currentToolId,
+            name: currentToolName,
+            input,
+          });
+          yield { type: "tool_use_end", id: currentToolId };
+          currentToolId = "";
+          currentToolName = "";
+          currentToolJson = "";
+        }
+      }
+    }
+
+    // Collect final text from stream
+    const finalMessage = await stream.finalMessage();
+    // Build content blocks from final message for accuracy
+    const finalContent: LlmContentBlock[] = finalMessage.content.map((block: any) => {
+      if (block.type === "text") return { type: "text" as const, text: block.text };
+      if (block.type === "tool_use") return { type: "tool_use" as const, id: block.id, name: block.name, input: block.input };
+      return block;
+    });
+
+    const finalUsage = finalMessage.usage as any;
+
+    yield {
+      type: "message_done",
+      response: {
+        content: finalContent,
+        stopReason: finalMessage.stop_reason ?? "end_turn",
+        usage: {
+          inputTokens: finalMessage.usage.input_tokens,
+          outputTokens: finalMessage.usage.output_tokens,
+          cacheCreationTokens: finalUsage.cache_creation_input_tokens ?? undefined,
+          cacheReadTokens: finalUsage.cache_read_input_tokens ?? undefined,
+        },
+      },
+    };
+  }
+}

package/src/llm/factory.ts

@@ -0,0 +1,115 @@
+import type { ZuboConfig, ProviderConfig } from "../config/schema";
+import type { LlmProvider } from "./provider";
+import { ClaudeProvider } from "./claude";
+import { OpenAICompatProvider } from "./openai-compat";
+import { FailoverProvider } from "./failover";
+import { SmartRouterProvider } from "./smart-router";
+import { logger } from "../util/logger";
+
+const KNOWN_BASE_URLS: Record<string, string> = {
+  openai: "https://api.openai.com/v1",
+  groq: "https://api.groq.com/openai/v1",
+  together: "https://api.together.xyz/v1",
+  openrouter: "https://openrouter.ai/api/v1",
+  deepseek: "https://api.deepseek.com/v1",
+  fireworks: "https://api.fireworks.ai/inference/v1",
+  cerebras: "https://api.cerebras.ai/v1",
+  perplexity: "https://api.perplexity.ai",
+  xai: "https://api.x.ai/v1",
+  ollama: "http://localhost:11434/v1",
+  lmstudio: "http://localhost:1234/v1",
+};
+
+function buildSingleProvider(
+  name: string,
+  providerCfg: ProviderConfig
+): LlmProvider {
+  const baseUrl = providerCfg.baseUrl ?? KNOWN_BASE_URLS[name];
+
+  if (name === "anthropic") {
+    if (!providerCfg.apiKey) {
+      throw new Error("Anthropic provider requires an apiKey");
+    }
+    const provider = new ClaudeProvider(providerCfg.apiKey, providerCfg.model);
+    if (providerCfg.contextWindow) provider.contextWindow = providerCfg.contextWindow;
+    return provider;
+  }
+
+  // Everything else goes through OpenAI-compatible
+  if (!baseUrl) {
+    throw new Error(
+      `Provider "${name}" requires a baseUrl. Known providers: ${Object.keys(KNOWN_BASE_URLS).join(", ")}`
+    );
+  }
+
+  return new OpenAICompatProvider({
+    name,
+    baseUrl,
+    apiKey: providerCfg.apiKey ?? "no-key",
+    model: providerCfg.model,
+    streaming: providerCfg.streaming,
+    contextWindow: providerCfg.contextWindow,
+  });
+}
+
+export function createProvider(config: ZuboConfig): LlmProvider {
+  // New multi-provider config
+  if (config.providers && config.activeProvider) {
+    const activeCfg = config.providers[config.activeProvider];
+    if (!activeCfg) {
+      throw new Error(
+        `Active provider "${config.activeProvider}" not found in providers config`
+      );
+    }
+
+    const primary = buildSingleProvider(config.activeProvider, activeCfg);
+    logger.info(`LLM provider: ${primary.providerName}/${primary.model}`);
+
+    // Build failover chain
+    let provider: LlmProvider = primary;
+    if (config.failover?.length) {
+      const fallbacks: LlmProvider[] = [];
+      for (const fbName of config.failover) {
+        const fbCfg = config.providers[fbName];
+        if (fbCfg) {
+          fallbacks.push(buildSingleProvider(fbName, fbCfg));
+          logger.info(`  failover: ${fbName}/${fbCfg.model}`);
+        } else {
+          logger.warn(`Failover provider "${fbName}" not configured, skipping`);
+        }
+      }
+      if (fallbacks.length) {
+        provider = new FailoverProvider(primary, fallbacks);
+      }
+    }
+
+    // Wrap in smart router if enabled
+    if (config.smartRouting?.enabled) {
+      const fastProviderName = config.smartRouting.fastProvider;
+      if (fastProviderName && config.providers[fastProviderName]) {
+        const fastCfg = { ...config.providers[fastProviderName] };
+        if (config.smartRouting.fastModel) {
+          fastCfg.model = config.smartRouting.fastModel;
+        }
+        const fast = buildSingleProvider(fastProviderName, fastCfg);
+        logger.info(`Smart routing enabled: fast=${fast.providerName}/${fast.model}`);
+        provider = new SmartRouterProvider(provider, fast, true);
+      } else {
+        logger.warn("Smart routing enabled but fastProvider not configured, skipping");
+      }
+    }
+
+    return provider;
+  }
+
+  // Legacy config: anthropicApiKey + model at top level
+  if (config.anthropicApiKey) {
+    const model = config.model ?? "claude-sonnet-4-5-20250929";
+    logger.info(`LLM provider: anthropic/${model} (legacy config)`);
+    return new ClaudeProvider(config.anthropicApiKey, model);
+  }
+
+  throw new Error(
+    "No LLM provider configured. Run 'zubo setup' or add a providers section to config.json"
+  );
+}

package/src/llm/failover.ts

@@ -0,0 +1,101 @@
+import type { LlmProvider, LlmRequest, LlmResponse, LlmStreamEvent } from "./provider";
+import { logger } from "../util/logger";
+
+export class FailoverProvider implements LlmProvider {
+  providerName: string;
+  model: string;
+  contextWindow: number;
+
+  constructor(
+    private primary: LlmProvider,
+    private fallbacks: LlmProvider[]
+  ) {
+    this.providerName = primary.providerName;
+    this.model = primary.model;
+    this.contextWindow = primary.contextWindow;
+  }
+
+  async chat(request: LlmRequest): Promise<LlmResponse> {
+    try {
+      return await this.primary.chat(request);
+    } catch (err: any) {
+      logger.warn(`Primary provider (${this.primary.providerName}) failed`, {
+        error: err.message,
+      });
+
+      for (const fb of this.fallbacks) {
+        try {
+          logger.info(`Trying fallback: ${fb.providerName}/${fb.model}`);
+          const result = await fb.chat(request);
+          this.providerName = fb.providerName;
+          this.model = fb.model;
+          return result;
+        } catch (fbErr: any) {
+          logger.warn(`Fallback ${fb.providerName} also failed`, {
+            error: fbErr.message,
+          });
+        }
+      }
+
+      throw new Error(
+        `All providers failed. Primary: ${err.message}`
+      );
+    }
+  }
+
+  async *chatStream(request: LlmRequest): AsyncIterable<LlmStreamEvent> {
+    const MAX_STREAM_EVENTS = 50_000;
+
+    // Collect all events from a stream — if it succeeds fully, yield them.
+    // This prevents partial output from a failing stream from corrupting state.
+    async function collectStream(provider: LlmProvider): Promise<LlmStreamEvent[] | null> {
+      if (!provider.chatStream) return null;
+      const events: LlmStreamEvent[] = [];
+      try {
+        for await (const event of provider.chatStream(request)) {
+          if (events.length >= MAX_STREAM_EVENTS) {
+            throw new Error(`Stream exceeded maximum event limit (${MAX_STREAM_EVENTS})`);
+          }
+          events.push(event);
+        }
+        return events;
+      } catch (err: any) {
+        logger.warn(`Stream from ${provider.providerName} failed after ${events.length} events`, {
+          error: err.message,
+        });
+        return null;
+      }
+    }
+
+    // Try primary
+    const primaryEvents = await collectStream(this.primary);
+    if (primaryEvents) {
+      for (const event of primaryEvents) yield event;
+      return;
+    }
+
+    // Try fallbacks
+    for (const fb of this.fallbacks) {
+      const fbEvents = await collectStream(fb);
+      if (fbEvents) {
+        this.providerName = fb.providerName;
+        this.model = fb.model;
+        for (const event of fbEvents) yield event;
+        return;
+      }
+    }
+
+    // If no provider supports streaming, fall back to non-streaming
+    logger.info("No streaming providers available, falling back to non-streaming");
+    const response = await this.chat(request);
+    for (const block of response.content) {
+      if (block.type === "text" && block.text) {
+        yield { type: "text_delta", text: block.text };
+      } else if (block.type === "tool_use") {
+        yield { type: "tool_use_start", id: block.id!, name: block.name! };
+        yield { type: "tool_use_end", id: block.id! };
+      }
+    }
+    yield { type: "message_done", response };
+  }
+}