wispy-cli 0.6.1 → 0.7.0

package/core/providers.mjs

@@ -0,0 +1,410 @@
+/**
+ * core/providers.mjs — Provider abstraction for Wispy
+ *
+ * Class ProviderRegistry:
+ *   - detect() → available providers list
+ *   - get(name) → Provider
+ *   - getDefault() → Provider (first available)
+ *   - chat(messages, tools, opts?) → response
+ *   - setModel(model) → void
+ *
+ * Each provider: { name, label, models, chat(messages, tools, opts) }
+ */
+
+import { PROVIDERS, detectProvider } from "./config.mjs";
+
+const OPENAI_COMPAT_ENDPOINTS = {
+  openai:     "https://api.openai.com/v1/chat/completions",
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+  groq:       "https://api.groq.com/openai/v1/chat/completions",
+  deepseek:   "https://api.deepseek.com/v1/chat/completions",
+  ollama:     `${process.env.OLLAMA_HOST ?? "http://localhost:11434"}/v1/chat/completions`,
+};
+
+export class ProviderRegistry {
+  constructor() {
+    this._detected = null;
+    this._provider = null;
+    this._apiKey = null;
+    this._model = null;
+    this._sessionTokens = { input: 0, output: 0 };
+  }
+
+  /**
+   * Initialize by detecting available provider.
+   */
+  async init(overrides = {}) {
+    const detected = await detectProvider();
+    if (!detected && !overrides.provider) {
+      return null;
+    }
+    this._provider = overrides.provider ?? detected?.provider;
+    this._apiKey = overrides.key ?? detected?.key;
+    this._model = overrides.model ?? detected?.model;
+    this._detected = detected;
+    return { provider: this._provider, key: this._apiKey, model: this._model };
+  }
+
+  get provider() { return this._provider; }
+  get apiKey() { return this._apiKey; }
+  get model() { return this._model; }
+  get sessionTokens() { return this._sessionTokens; }
+
+  setModel(model) {
+    this._model = model;
+    process.env.WISPY_MODEL = model;
+  }
+
+  detect() {
+    return Object.entries(PROVIDERS)
+      .filter(([id, p]) => {
+        for (const k of p.envKeys) { if (process.env[k]) return true; }
+        return p.local && process.env.OLLAMA_HOST;
+      })
+      .map(([id, p]) => ({ id, label: p.label, defaultModel: p.defaultModel }));
+  }
+
+  get(name) {
+    return PROVIDERS[name] ?? null;
+  }
+
+  getDefault() {
+    return PROVIDERS[this._provider] ?? null;
+  }
+
+  _estimateTokens(text) {
+    return Math.ceil((text?.length ?? 0) / 4);
+  }
+
+  /**
+   * Main chat entrypoint. Routes to the correct provider.
+   * messages: array of { role, content, toolCalls?, ... }
+   * tools: array of tool definitions
+   * opts: { onChunk?(chunk), model? }
+   * Returns: { type: "text"|"tool_calls", text?, calls? }
+   */
+  async chat(messages, tools = [], opts = {}) {
+    const model = opts.model ?? this._model;
+    if (this._provider === "google") {
+      return this._chatGemini(messages, tools, opts, model);
+    }
+    if (this._provider === "anthropic") {
+      return this._chatAnthropic(messages, tools, opts, model);
+    }
+    return this._chatOpenAICompat(messages, tools, opts, model);
+  }
+
+  async _chatGemini(messages, tools, opts, model) {
+    const systemInstruction = messages.find(m => m.role === "system")?.content ?? "";
+    const contents = [];
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      if (m.role === "tool_result") {
+        contents.push({
+          role: "user",
+          parts: [{ functionResponse: { name: m.toolName, response: m.result } }],
+        });
+      } else if (m.role === "assistant" && m.toolCalls) {
+        contents.push({
+          role: "model",
+          parts: m.toolCalls.map(tc => ({
+            functionCall: { name: tc.name, args: tc.args },
+          })),
+        });
+      } else {
+        contents.push({
+          role: m.role === "assistant" ? "model" : "user",
+          parts: [{ text: m.content }],
+        });
+      }
+    }
+
+    const inputText = contents.map(c => c.parts?.map(p => p.text ?? JSON.stringify(p)).join("")).join("");
+    this._sessionTokens.input += this._estimateTokens(systemInstruction + inputText);
+
+    const geminiTools = tools.length > 0 ? [{
+      functionDeclarations: tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      })),
+    }] : [];
+
+    const hasToolResults = messages.some(m => m.role === "tool_result");
+    const useStreaming = !hasToolResults;
+    const endpoint = useStreaming ? "streamGenerateContent" : "generateContent";
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:${endpoint}?${useStreaming ? "alt=sse&" : ""}key=${this._apiKey}`;
+
+    const body = {
+      system_instruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
+      contents,
+      generationConfig: { temperature: 0.7, maxOutputTokens: 4096 },
+    };
+    if (geminiTools.length > 0) body.tools = geminiTools;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Gemini API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    if (useStreaming) {
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let fullText = "";
+      let sseBuffer = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        sseBuffer += decoder.decode(value, { stream: true });
+        const sseLines = sseBuffer.split("\n");
+        sseBuffer = sseLines.pop() ?? "";
+
+        for (const line of sseLines) {
+          if (!line.startsWith("data: ")) continue;
+          const ld = line.slice(6).trim();
+          if (!ld || ld === "[DONE]") continue;
+          try {
+            const parsed = JSON.parse(ld);
+            const streamParts = parsed.candidates?.[0]?.content?.parts ?? [];
+            const streamFC = streamParts.filter(p => p.functionCall);
+            if (streamFC.length > 0) {
+              this._sessionTokens.output += this._estimateTokens(JSON.stringify(streamFC));
+              return { type: "tool_calls", calls: streamFC.map(p => ({ name: p.functionCall.name, args: p.functionCall.args })) };
+            }
+            const t = streamParts.map(p => p.text ?? "").join("");
+            if (t) { fullText += t; opts.onChunk?.(t); }
+          } catch { /* skip */ }
+        }
+      }
+      this._sessionTokens.output += this._estimateTokens(fullText);
+      return { type: "text", text: fullText };
+    }
+
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    if (!candidate) throw new Error("No response from Gemini");
+
+    const parts = candidate.content?.parts ?? [];
+    const functionCalls = parts.filter(p => p.functionCall);
+    if (functionCalls.length > 0) {
+      this._sessionTokens.output += this._estimateTokens(JSON.stringify(functionCalls));
+      return { type: "tool_calls", calls: functionCalls.map(p => ({ name: p.functionCall.name, args: p.functionCall.args })) };
+    }
+
+    const text = parts.map(p => p.text ?? "").join("");
+    this._sessionTokens.output += this._estimateTokens(text);
+    opts.onChunk?.(text);
+    return { type: "text", text };
+  }
+
+  async _chatAnthropic(messages, tools, opts, model) {
+    const systemPrompt = messages.find(m => m.role === "system")?.content ?? "";
+    const anthropicMessages = [];
+
+    for (const m of messages) {
+      if (m.role === "system") continue;
+      if (m.role === "tool_result") {
+        anthropicMessages.push({
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: m.toolUseId ?? m.toolName, content: JSON.stringify(m.result) }],
+        });
+      } else if (m.role === "assistant" && m.toolCalls) {
+        anthropicMessages.push({
+          role: "assistant",
+          content: m.toolCalls.map(tc => ({
+            type: "tool_use", id: tc.id ?? tc.name, name: tc.name, input: tc.args,
+          })),
+        });
+      } else {
+        anthropicMessages.push({
+          role: m.role === "assistant" ? "assistant" : "user",
+          content: m.content,
+        });
+      }
+    }
+
+    const inputText = anthropicMessages.map(m => typeof m.content === "string" ? m.content : JSON.stringify(m.content)).join("");
+    this._sessionTokens.input += this._estimateTokens(systemPrompt + inputText);
+
+    const anthropicTools = tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+    }));
+
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this._apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        messages: anthropicMessages,
+        tools: anthropicTools,
+        stream: true,
+      }),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`Anthropic API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    const toolCalls = [];
+    let currentToolCall = null;
+    let currentToolInput = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (!data) continue;
+
+        try {
+          const event = JSON.parse(data);
+          if (event.type === "content_block_start") {
+            if (event.content_block?.type === "tool_use") {
+              currentToolCall = { id: event.content_block.id, name: event.content_block.name, args: {} };
+              currentToolInput = "";
+            }
+          } else if (event.type === "content_block_delta") {
+            if (event.delta?.type === "text_delta") {
+              fullText += event.delta.text;
+              opts.onChunk?.(event.delta.text);
+            } else if (event.delta?.type === "input_json_delta") {
+              currentToolInput += event.delta.partial_json ?? "";
+            }
+          } else if (event.type === "content_block_stop") {
+            if (currentToolCall) {
+              try { currentToolCall.args = JSON.parse(currentToolInput); } catch { currentToolCall.args = {}; }
+              toolCalls.push(currentToolCall);
+              currentToolCall = null;
+              currentToolInput = "";
+            }
+          }
+        } catch { /* skip */ }
+      }
+    }
+
+    this._sessionTokens.output += this._estimateTokens(fullText + JSON.stringify(toolCalls));
+
+    if (toolCalls.length > 0) {
+      return { type: "tool_calls", calls: toolCalls };
+    }
+    return { type: "text", text: fullText };
+  }
+
+  async _chatOpenAICompat(messages, tools, opts, model) {
+    const openaiMessages = messages.map(m => {
+      if (m.role === "tool_result") {
+        return { role: "tool", tool_call_id: m.toolCallId ?? m.toolName, content: JSON.stringify(m.result) };
+      }
+      if (m.role === "assistant" && m.toolCalls) {
+        return {
+          role: "assistant",
+          content: null,
+          tool_calls: m.toolCalls.map((tc, i) => ({
+            id: tc.id ?? `call_${i}`,
+            type: "function",
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+          })),
+        };
+      }
+      return { role: m.role, content: m.content };
+    });
+
+    const inputText = openaiMessages.map(m => m.content ?? "").join("");
+    this._sessionTokens.input += this._estimateTokens(inputText);
+
+    const endpoint = OPENAI_COMPAT_ENDPOINTS[this._provider] ?? OPENAI_COMPAT_ENDPOINTS.openai;
+    const headers = { "Content-Type": "application/json" };
+    if (this._apiKey) headers["Authorization"] = `Bearer ${this._apiKey}`;
+    if (this._provider === "openrouter") headers["HTTP-Referer"] = "https://wispy.dev";
+
+    const supportsTools = !["ollama"].includes(this._provider);
+    const body = { model, messages: openaiMessages, temperature: 0.7, max_tokens: 4096 };
+    if (supportsTools && tools.length > 0) {
+      body.tools = tools.map(t => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters },
+      }));
+    }
+
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(`OpenAI API error ${response.status}: ${err.slice(0, 300)}`);
+    }
+
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice) throw new Error("No response from OpenAI");
+
+    if (choice.message?.tool_calls?.length > 0) {
+      const calls = choice.message.tool_calls.map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        args: JSON.parse(tc.function.arguments),
+      }));
+      this._sessionTokens.output += this._estimateTokens(JSON.stringify(calls));
+      return { type: "tool_calls", calls };
+    }
+
+    const text = choice.message?.content ?? "";
+    this._sessionTokens.output += this._estimateTokens(text);
+    opts.onChunk?.(text);
+    return { type: "text", text };
+  }
+
+  formatCost() {
+    const MODEL_PRICING = {
+      "gemini-2.5-flash":   { input: 0.15,  output: 0.60 },
+      "gemini-2.5-pro":     { input: 1.25,  output: 10.0 },
+      "gemini-2.0-flash":   { input: 0.10,  output: 0.40 },
+      "claude-sonnet-4-20250514": { input: 3.0, output: 15.0 },
+      "claude-opus-4-6":    { input: 15.0,  output: 75.0 },
+      "claude-haiku-3.5":   { input: 0.80,  output: 4.0 },
+      "gpt-4o":             { input: 2.50,  output: 10.0 },
+      "gpt-4o-mini":        { input: 0.15,  output: 0.60 },
+      "gpt-4.1":            { input: 2.0,   output: 8.0 },
+      "gpt-4.1-mini":       { input: 0.40,  output: 1.60 },
+      "gpt-4.1-nano":       { input: 0.10,  output: 0.40 },
+      "o4-mini":            { input: 1.10,  output: 4.40 },
+      "llama-3.3-70b-versatile": { input: 0.59, output: 0.79 },
+      "deepseek-chat":      { input: 0.27,  output: 1.10 },
+      "llama3.2":           { input: 0,     output: 0 },
+    };
+    const pricing = MODEL_PRICING[this._model] ?? { input: 1.0, output: 3.0 };
+    const cost = (this._sessionTokens.input * pricing.input + this._sessionTokens.output * pricing.output) / 1_000_000;
+    const total = this._sessionTokens.input + this._sessionTokens.output;
+    return `${total} tokens (~$${cost.toFixed(4)})`;
+  }
+}

package/core/session.mjs

@@ -0,0 +1,196 @@
+/**
+ * core/session.mjs — Session management for Wispy
+ *
+ * Class SessionManager:
+ *   - create({ workstream?, channel?, chatId? }) → Session
+ *   - get(id) → Session
+ *   - list(filter?) → Session[]
+ *   - addMessage(id, message) → void
+ *   - clear(id) → void
+ *   - save(id) → void
+ *   - load(id) → Session
+ *   - getOrCreate(key) → Session  (for channel adapters: key = "telegram:chatId")
+ *
+ * File-based persistence: ~/.wispy/sessions/{id}.json
+ */
+
+import os from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { SESSIONS_DIR } from "./config.mjs";
+
+export class Session {
+  constructor({ id, workstream = "default", channel = null, chatId = null, messages = [], createdAt = null }) {
+    this.id = id;
+    this.workstream = workstream;
+    this.channel = channel;
+    this.chatId = chatId;
+    this.messages = messages;
+    this.createdAt = createdAt ?? new Date().toISOString();
+    this.updatedAt = new Date().toISOString();
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      workstream: this.workstream,
+      channel: this.channel,
+      chatId: this.chatId,
+      messages: this.messages,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+    };
+  }
+}
+
+export class SessionManager {
+  constructor() {
+    this._sessions = new Map(); // id → Session (in-memory cache)
+    this._keyMap = new Map();   // composite key → id (for getOrCreate)
+  }
+
+  /**
+   * Create a new session
+   */
+  create({ workstream = "default", channel = null, chatId = null } = {}) {
+    const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const session = new Session({ id, workstream, channel, chatId });
+    this._sessions.set(id, session);
+    if (channel && chatId) {
+      this._keyMap.set(`${channel}:${chatId}`, id);
+    }
+    return session;
+  }
+
+  /**
+   * Get a session by ID. Returns null if not found in memory.
+   */
+  get(id) {
+    return this._sessions.get(id) ?? null;
+  }
+
+  /**
+   * Get or load a session by ID.
+   */
+  async getOrLoad(id) {
+    if (this._sessions.has(id)) return this._sessions.get(id);
+    return this.load(id);
+  }
+
+  /**
+   * List sessions matching an optional filter.
+   */
+  list(filter = null) {
+    const all = Array.from(this._sessions.values());
+    if (!filter) return all;
+    return all.filter(s => {
+      if (filter.workstream && s.workstream !== filter.workstream) return false;
+      if (filter.channel && s.channel !== filter.channel) return false;
+      return true;
+    });
+  }
+
+  /**
+   * Add a message to a session.
+   */
+  addMessage(id, message) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    session.messages.push(message);
+    session.updatedAt = new Date().toISOString();
+    // Keep last 50 messages
+    if (session.messages.length > 50) {
+      session.messages = session.messages.slice(-50);
+    }
+  }
+
+  /**
+   * Clear message history for a session.
+   */
+  clear(id) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    session.messages = [];
+    session.updatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Save a session to disk.
+   */
+  async save(id) {
+    const session = this._sessions.get(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    await writeFile(filePath, JSON.stringify(session.toJSON(), null, 2) + "\n", "utf8");
+  }
+
+  /**
+   * Load a session from disk.
+   */
+  async load(id) {
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    try {
+      const raw = await readFile(filePath, "utf8");
+      const data = JSON.parse(raw);
+      const session = new Session(data);
+      this._sessions.set(id, session);
+      if (session.channel && session.chatId) {
+        this._keyMap.set(`${session.channel}:${session.chatId}`, id);
+      }
+      return session;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get or create a session by a composite key (e.g., "telegram:chatId").
+   * Used by channel adapters to maintain per-chat sessions.
+   */
+  async getOrCreate(key, opts = {}) {
+    // Check in-memory key map
+    if (this._keyMap.has(key)) {
+      const id = this._keyMap.get(key);
+      if (this._sessions.has(id)) return this._sessions.get(id);
+    }
+
+    // Try to find on disk by scanning sessions dir
+    try {
+      const files = await readdir(SESSIONS_DIR);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const id = file.replace(".json", "");
+        const existing = await this.load(id);
+        if (existing) {
+          const existingKey = existing.channel && existing.chatId
+            ? `${existing.channel}:${existing.chatId}`
+            : null;
+          if (existingKey === key) return existing;
+        }
+      }
+    } catch { /* sessions dir might not exist yet */ }
+
+    // Parse channel:chatId from key
+    const colonIdx = key.indexOf(":");
+    const channel = colonIdx !== -1 ? key.slice(0, colonIdx) : null;
+    const chatId = colonIdx !== -1 ? key.slice(colonIdx + 1) : key;
+
+    const session = this.create({ channel, chatId, ...opts });
+    this._keyMap.set(key, session.id);
+    return session;
+  }
+
+  /**
+   * Get all messages for a session, including a system prompt prefix.
+   * Ensures the system message is always first.
+   */
+  getMessages(id) {
+    const session = this._sessions.get(id);
+    if (!session) return [];
+    return session.messages;
+  }
+}
+
+// Default global instance
+export const sessionManager = new SessionManager();