wispy-cli 0.6.0 → 0.7.0

package/lib/channels/index.mjs

@@ -1,5 +1,6 @@
 /**
  * Channel Manager — loads config, starts/stops adapters, routes messages
+ * v0.7: uses core/engine.mjs and core/session.mjs for AI and session management
  *
  * Config: ~/.wispy/channels.json
  *   {
@@ -7,19 +8,22 @@
  *     "discord":  { "enabled": true, "token": "..." },
  *     "slack":    { "enabled": true, "botToken": "...", "appToken": "..." }
  *   }
- *
- * Per-chat conversation history is stored in ~/.wispy/channel-sessions/<channel>/<chatId>.json
  */
 
 import os from "node:os";
 import path from "node:path";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+import {
+  WispyEngine,
+  sessionManager,
+  WISPY_DIR,
+} from "../../core/index.mjs";
 
 // ── Paths ─────────────────────────────────────────────────────────────────────
 
-const WISPY_DIR       = path.join(os.homedir(), ".wispy");
 const CHANNELS_CONFIG = path.join(WISPY_DIR, "channels.json");
-const SESSIONS_DIR    = path.join(WISPY_DIR, "channel-sessions");
 
 // ── Config helpers ────────────────────────────────────────────────────────────
 
@@ -37,245 +41,59 @@ export async function saveChannelsConfig(cfg) {
   await writeFile(CHANNELS_CONFIG, JSON.stringify(cfg, null, 2) + "\n", "utf8");
 }
 
-// ── Per-chat session storage ──────────────────────────────────────────────────
+// ── Shared AI engine ──────────────────────────────────────────────────────────
 
-async function sessionPath(channelName, chatId) {
-  const dir = path.join(SESSIONS_DIR, channelName);
-  await mkdir(dir, { recursive: true });
-  // Sanitize chatId to be filename-safe
-  const safe = String(chatId).replace(/[^a-zA-Z0-9_\-]/g, "_");
-  return path.join(dir, `${safe}.json`);
-}
+let _sharedEngine = null;
 
-async function loadSession(channelName, chatId) {
-  try {
-    const raw = await readFile(await sessionPath(channelName, chatId), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return [];
-  }
-}
+async function getEngine() {
+  if (_sharedEngine) return _sharedEngine;
 
-async function saveSession(channelName, chatId, messages) {
-  const p = await sessionPath(channelName, chatId);
-  const trimmed = messages.slice(-50);
-  await writeFile(p, JSON.stringify(trimmed, null, 2) + "\n", "utf8");
-}
+  const engine = new WispyEngine({ workstream: "channels" });
+  const result = await engine.init();
+  if (!result) return null;
 
-async function clearSession(channelName, chatId) {
-  await saveSession(channelName, chatId, []);
+  _sharedEngine = engine;
+  return engine;
 }
 
-// ── AI engine (minimal inline, reuses provider detection from wispy-repl logic)─
-
-import { createInterface } from "node:readline";
-import { appendFile } from "node:fs/promises";
-
-const PROVIDERS = {
-  google:     { envKeys: ["GOOGLE_AI_KEY", "GEMINI_API_KEY"], defaultModel: "gemini-2.5-flash" },
-  anthropic:  { envKeys: ["ANTHROPIC_API_KEY"], defaultModel: "claude-sonnet-4-20250514" },
-  openai:     { envKeys: ["OPENAI_API_KEY"], defaultModel: "gpt-4o" },
-  openrouter: { envKeys: ["OPENROUTER_API_KEY"], defaultModel: "anthropic/claude-sonnet-4-20250514" },
-  groq:       { envKeys: ["GROQ_API_KEY"], defaultModel: "llama-3.3-70b-versatile" },
-  deepseek:   { envKeys: ["DEEPSEEK_API_KEY"], defaultModel: "deepseek-chat" },
-  ollama:     { envKeys: ["OLLAMA_HOST"], defaultModel: "llama3.2", local: true },
-};
-
-function getEnvKey(envKeys) {
-  for (const k of envKeys) { if (process.env[k]) return process.env[k]; }
-  return null;
-}
-
-async function tryKeychainKey(service) {
-  try {
-    const { execFile } = await import("node:child_process");
-    const { promisify } = await import("node:util");
-    const exec = promisify(execFile);
-    const { stdout } = await exec("security", ["find-generic-password", "-s", service, "-a", "poropo", "-w"], { timeout: 3000 });
-    return stdout.trim() || null;
-  } catch { return null; }
-}
-
-let _detectedProvider = null;
-
-async function getProvider() {
-  if (_detectedProvider) return _detectedProvider;
-
-  // WISPY_PROVIDER override
-  const forced = process.env.WISPY_PROVIDER;
-  if (forced && PROVIDERS[forced]) {
-    const key = getEnvKey(PROVIDERS[forced].envKeys);
-    if (key || PROVIDERS[forced].local) {
-      _detectedProvider = { provider: forced, key, model: process.env.WISPY_MODEL ?? PROVIDERS[forced].defaultModel };
-      return _detectedProvider;
-    }
-  }
-
-  // Config file
-  try {
-    const cfg = JSON.parse(await readFile(path.join(WISPY_DIR, "config.json"), "utf8"));
-    if (cfg.provider && PROVIDERS[cfg.provider]) {
-      const key = getEnvKey(PROVIDERS[cfg.provider].envKeys) ?? cfg.apiKey;
-      if (key || PROVIDERS[cfg.provider].local) {
-        _detectedProvider = { provider: cfg.provider, key, model: cfg.model ?? PROVIDERS[cfg.provider].defaultModel };
-        return _detectedProvider;
-      }
-    }
-  } catch {}
-
-  // Auto-detect env
-  for (const p of ["google","anthropic","openai","openrouter","groq","deepseek","ollama"]) {
-    const key = getEnvKey(PROVIDERS[p].envKeys);
-    if (key || (p === "ollama" && process.env.OLLAMA_HOST)) {
-      _detectedProvider = { provider: p, key, model: process.env.WISPY_MODEL ?? PROVIDERS[p].defaultModel };
-      return _detectedProvider;
-    }
-  }
-
-  // macOS Keychain
-  for (const [service, provider] of [["google-ai-key","google"],["anthropic-api-key","anthropic"],["openai-api-key","openai"]]) {
-    const key = await tryKeychainKey(service);
-    if (key) {
-      process.env[PROVIDERS[provider].envKeys[0]] = key;
-      _detectedProvider = { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
-      return _detectedProvider;
-    }
-  }
-
-  return null;
-}
-
-const OPENAI_COMPAT = {
-  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`,
-};
-
-async function callLLM(messages, providerInfo) {
-  const { provider, key, model } = providerInfo;
-
-  if (provider === "google") {
-    return callGemini(messages, key, model);
-  }
-  if (provider === "anthropic") {
-    return callAnthropic(messages, key, model);
-  }
-  return callOpenAICompat(messages, key, model, provider);
-}
-
-async function callGemini(messages, key, model) {
-  const systemInstruction = messages.find(m => m.role === "system")?.content ?? "";
-  const contents = messages
-    .filter(m => m.role !== "system")
-    .map(m => ({
-      role: m.role === "assistant" ? "model" : "user",
-      parts: [{ text: m.content }],
-    }));
-
-  const resp = await fetch(
-    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        system_instruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
-        contents,
-        generationConfig: { temperature: 0.7, maxOutputTokens: 4096 },
-      }),
-    }
-  );
-  if (!resp.ok) throw new Error(`Gemini API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
-  const data = await resp.json();
-  return data.candidates?.[0]?.content?.parts?.map(p => p.text ?? "").join("") ?? "";
-}
-
-async function callAnthropic(messages, key, model) {
-  const systemPrompt = messages.find(m => m.role === "system")?.content ?? "";
-  const anthropicMessages = messages.filter(m => m.role !== "system").map(m => ({
-    role: m.role === "assistant" ? "assistant" : "user",
-    content: m.content,
-  }));
-
-  const resp = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: { "Content-Type": "application/json", "x-api-key": key, "anthropic-version": "2023-06-01" },
-    body: JSON.stringify({ model, max_tokens: 4096, system: systemPrompt, messages: anthropicMessages }),
-  });
-  if (!resp.ok) throw new Error(`Anthropic API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
-  const data = await resp.json();
-  return data.content?.map(c => c.text ?? "").join("") ?? "";
-}
-
-async function callOpenAICompat(messages, key, model, provider) {
-  const endpoint = OPENAI_COMPAT[provider] ?? OPENAI_COMPAT.openai;
-  const headers = { "Content-Type": "application/json" };
-  if (key) headers["Authorization"] = `Bearer ${key}`;
-  if (provider === "openrouter") headers["HTTP-Referer"] = "https://wispy.dev";
-
-  const oaiMessages = messages.filter(m => m.role !== "tool_result").map(m => ({
-    role: m.role === "assistant" ? "assistant" : m.role,
-    content: m.content,
-  }));
-
-  const resp = await fetch(endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ model, messages: oaiMessages, temperature: 0.7, max_tokens: 4096 }),
-  });
-  if (!resp.ok) throw new Error(`OpenAI-compat API error ${resp.status}: ${await resp.text().then(t => t.slice(0,200))}`);
-  const data = await resp.json();
-  return data.choices?.[0]?.message?.content ?? "";
-}
-
-const SYSTEM_PROMPT = `You are Wispy 🌿 — a small ghost AI assistant living in chat platforms.
+// System prompt for channel context
+const CHANNEL_SYSTEM_PROMPT = `You are Wispy 🌿 — a small ghost AI assistant living in chat platforms.
 You're helpful, concise, and friendly. You can answer questions, write code, help with tasks.
 Keep responses concise and conversational. End each message with 🌿.
 Respond in the same language the user writes in.`;
 
 /**
  * Process a user message and return Wispy's response.
- * Maintains per-chat conversation history.
+ * Uses core/engine.mjs for AI and core/session.mjs for per-chat sessions.
  */
 export async function processUserMessage(channelName, chatId, userText) {
   // Handle __CLEAR__ signal
   if (userText === "__CLEAR__") {
-    await clearSession(channelName, chatId);
+    const key = `${channelName}:${chatId}`;
+    const session = await sessionManager.getOrCreate(key, { channel: channelName });
+    sessionManager.clear(session.id);
+    await sessionManager.save(session.id);
     return null; // Caller should send confirmation
   }
 
-  const providerInfo = await getProvider();
-  if (!providerInfo) {
+  const engine = await getEngine();
+  if (!engine) {
     return "⚠️ No AI provider configured. Run `wispy` first to set up your API key. 🌿";
   }
 
-  // Load conversation history
-  const history = await loadSession(channelName, chatId);
-
-  // Build messages array
-  const messages = [
-    { role: "system", content: SYSTEM_PROMPT },
-    ...history,
-    { role: "user", content: userText },
-  ];
+  // Get or create per-chat session
+  const key = `${channelName}:${chatId}`;
+  const session = await sessionManager.getOrCreate(key, { channel: channelName, chatId: String(chatId) });
 
-  let response;
   try {
-    response = await callLLM(messages, providerInfo);
+    const result = await engine.processMessage(session.id, userText, {
+      systemPrompt: CHANNEL_SYSTEM_PROMPT,
+      noSave: false,
+    });
+    return result.content;
   } catch (err) {
     return `❌ Error: ${err.message.slice(0, 200)} 🌿`;
   }
-
-  // Save history (keep last 40 turns)
-  const updatedHistory = [
-    ...history,
-    { role: "user", content: userText },
-    { role: "assistant", content: response },
-  ].slice(-40);
-  await saveSession(channelName, chatId, updatedHistory);
-
-  return response;
 }
 
 // ── ChannelManager ────────────────────────────────────────────────────────────
@@ -307,7 +125,6 @@ export class ChannelManager {
         continue;
       }
 
-      // Check if at least one token is present
       const hasToken = this._hasToken(name, channelCfg);
       if (!hasToken) {
         console.log(`⚠  ${name}: no token configured — skipping (run \`wispy channel setup ${name}\`)`);
@@ -361,11 +178,12 @@ export class ChannelManager {
       }
     }
     this._adapters.clear();
+    if (_sharedEngine) { _sharedEngine.destroy(); _sharedEngine = null; }
   }
 
   _hasToken(name, cfg) {
     if (name === "telegram") return !!(process.env.WISPY_TELEGRAM_TOKEN ?? cfg.token);
-    if (name === "discord")  return !!(process.env.WISPY_DISCORD_TOKEN  ?? cfg.token);
+    if (name === "discord")  return !!(process.env.WISPY_DISCORD_TOKEN ?? cfg.token);
     if (name === "slack")    return !!(
       (process.env.WISPY_SLACK_BOT_TOKEN ?? cfg.botToken) &&
       (process.env.WISPY_SLACK_APP_TOKEN ?? cfg.appToken)
@@ -381,7 +199,6 @@ export async function channelSetup(channelName) {
   const ask = (q) => new Promise(r => rl.question(q, r));
 
   const cfg = await loadChannelsConfig();
-
   console.log(`\n🌿 Setting up ${channelName} channel\n`);
 
   if (channelName === "telegram") {
@@ -409,9 +226,7 @@ export async function channelSetup(channelName) {
   else if (channelName === "slack") {
     console.log("1. Go to https://api.slack.com/apps → Create New App → From scratch");
     console.log("2. Enable Socket Mode → copy App-Level Token (starts with xapp-)");
-    console.log("3. OAuth & Permissions → copy Bot User OAuth Token (starts with xoxb-)");
-    console.log("4. Subscribe to: app_mention, message.im events");
-    console.log("5. Add /wispy slash command\n");
+    console.log("3. OAuth & Permissions → copy Bot User OAuth Token (starts with xoxb-)\n");
     const botToken = (await ask("  Paste bot token (xoxb-...): ")).trim();
     const appToken = (await ask("  Paste app token (xapp-...): ")).trim();
     if (!botToken || !appToken) { rl.close(); return; }
@@ -434,14 +249,9 @@ export async function channelList() {
   console.log("\n🌿 Configured channels:\n");
   for (const name of channels) {
     const c = cfg[name];
-    if (!c) {
-      console.log(`  ○ ${name.padEnd(10)} not configured`);
-      continue;
-    }
+    if (!c) { console.log(`  ○ ${name.padEnd(10)} not configured`); continue; }
     const enabled = c.enabled !== false;
-    const hasToken = name === "slack"
-      ? !!(c.botToken && c.appToken)
-      : !!c.token;
+    const hasToken = name === "slack" ? !!(c.botToken && c.appToken) : !!c.token;
     const status = !hasToken ? "no token" : enabled ? "✅ enabled" : "disabled";
     console.log(`  ${enabled && hasToken ? "●" : "○"} ${name.padEnd(10)} ${status}`);
   }
@@ -463,9 +273,7 @@ export async function channelTest(channelName) {
       const me = await bot.api.getMe();
       console.log(`✅ Connected as @${me.username} (${me.first_name})`);
       await bot.stop().catch(() => {});
-    } catch (err) {
-      console.log(`❌ ${err.message}`);
-    }
+    } catch (err) { console.log(`❌ ${err.message}`); }
   }
 
   else if (channelName === "discord") {
@@ -477,9 +285,7 @@ export async function channelTest(channelName) {
       await client.login(token);
       console.log(`✅ Connected as ${client.user?.tag}`);
       await client.destroy();
-    } catch (err) {
-      console.log(`❌ ${err.message}`);
-    }
+    } catch (err) { console.log(`❌ ${err.message}`); }
   }
 
   else if (channelName === "slack") {
@@ -490,18 +296,11 @@ export async function channelTest(channelName) {
         headers: { Authorization: `Bearer ${botToken}` },
       });
       const data = await resp.json();
-      if (data.ok) {
-        console.log(`✅ Connected as @${data.user} on team ${data.team}`);
-      } else {
-        console.log(`❌ Slack error: ${data.error}`);
-      }
-    } catch (err) {
-      console.log(`❌ ${err.message}`);
-    }
+      if (data.ok) console.log(`✅ Connected as @${data.user} on team ${data.team}`);
+      else console.log(`❌ Slack error: ${data.error}`);
+    } catch (err) { console.log(`❌ ${err.message}`); }
   }
 
-  else {
-    console.log(`Unknown channel: ${channelName}`);
-  }
+  else { console.log(`Unknown channel: ${channelName}`); }
   console.log("");
 }