wispy-cli 0.6.1 → 0.7.0

package/lib/wispy-tui.mjs

@@ -1,32 +1,31 @@
 #!/usr/bin/env node
 /**
  * wispy-tui.mjs — Ink-based TUI for Wispy
+ * v0.7: uses core/engine.mjs for AI interaction
  *
  * Features:
  *  - Status bar: provider / model / workstream / session cost
  *  - Message list with basic markdown rendering
- *  - Tool execution display (collapsible)
+ *  - Tool execution display
  *  - Input box (single-line with submit)
  *  - Loading spinner while AI is thinking
  */
 
 import React, { useState, useEffect, useRef, useCallback } from "react";
-import { render, Box, Text, useInput, useApp, Newline } from "ink";
+import { render, Box, Text, useApp, Newline } from "ink";
 import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 
-// -----------------------------------------------------------------------
-// Inline helpers (avoid importing from wispy-repl to keep TUI standalone)
-// -----------------------------------------------------------------------
-
 import os from "node:os";
 import path from "node:path";
-import { readFile, writeFile, mkdir, appendFile } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+import { WispyEngine, CONVERSATIONS_DIR, PROVIDERS } from "../core/index.mjs";
 
-const WISPY_DIR = path.join(os.homedir(), ".wispy");
-const CONVERSATIONS_DIR = path.join(WISPY_DIR, "conversations");
+// -----------------------------------------------------------------------
+// Parse workstream from args
+// -----------------------------------------------------------------------
 
-// Parse workstream & provider from args
 const rawArgs = process.argv.slice(2);
 const wsIdx = rawArgs.findIndex((a) => a === "-w" || a === "--workstream");
 const ACTIVE_WORKSTREAM =
@@ -34,69 +33,11 @@ const ACTIVE_WORKSTREAM =
   (wsIdx !== -1 ? rawArgs[wsIdx + 1] : null) ??
   "default";
 
-const HISTORY_FILE = path.join(
-  CONVERSATIONS_DIR,
-  `${ACTIVE_WORKSTREAM}.json`
-);
-
-// Provider detection (quick version)
-const PROVIDERS = {
-  google:     { envKeys: ["GOOGLE_AI_KEY", "GEMINI_API_KEY"], defaultModel: "gemini-2.5-flash", label: "Gemini" },
-  anthropic:  { envKeys: ["ANTHROPIC_API_KEY"],               defaultModel: "claude-sonnet-4-20250514", label: "Claude" },
-  openai:     { envKeys: ["OPENAI_API_KEY"],                  defaultModel: "gpt-4o", label: "OpenAI" },
-  openrouter: { envKeys: ["OPENROUTER_API_KEY"],              defaultModel: "anthropic/claude-sonnet-4-20250514", label: "OpenRouter" },
-  groq:       { envKeys: ["GROQ_API_KEY"],                    defaultModel: "llama-3.3-70b-versatile", label: "Groq" },
-  deepseek:   { envKeys: ["DEEPSEEK_API_KEY"],                defaultModel: "deepseek-chat", label: "DeepSeek" },
-  ollama:     { envKeys: ["OLLAMA_HOST"],                     defaultModel: "llama3.2", label: "Ollama" },
-};
-
-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; }
-}
-
-async function detectProvider() {
-  // Check config
-  try {
-    const cfg = JSON.parse(await readFile(path.join(WISPY_DIR, "config.json"), "utf8"));
-    if (cfg.provider && PROVIDERS[cfg.provider]) {
-      const envKey = PROVIDERS[cfg.provider].envKeys.map(k => process.env[k]).find(Boolean) ?? cfg.apiKey;
-      if (envKey || cfg.provider === "ollama") {
-        return { provider: cfg.provider, key: envKey, model: cfg.model ?? PROVIDERS[cfg.provider].defaultModel };
-      }
-    }
-  } catch { /* no config */ }
-
-  // Env vars
-  for (const [p, info] of Object.entries(PROVIDERS)) {
-    const key = info.envKeys.map(k => process.env[k]).find(Boolean);
-    if (key || (p === "ollama" && process.env.OLLAMA_HOST)) {
-      return { provider: p, key, model: process.env.WISPY_MODEL ?? info.defaultModel };
-    }
-  }
-
-  // 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;
-      return { provider, key, model: process.env.WISPY_MODEL ?? PROVIDERS[provider].defaultModel };
-    }
-  }
+const HISTORY_FILE = path.join(CONVERSATIONS_DIR, `${ACTIVE_WORKSTREAM}.json`);
 
-  return null;
-}
+// -----------------------------------------------------------------------
+// Conversation persistence (for backward compat with CLI sessions)
+// -----------------------------------------------------------------------
 
 async function readFileOr(p, fallback = null) {
   try { return await readFile(p, "utf8"); } catch { return fallback; }
@@ -120,512 +61,129 @@ async function saveConversation(messages) {
 function renderMarkdown(text) {
   const lines = text.split("\n");
   return lines.map((line, i) => {
-    // Code block markers (just show as-is in dim)
-    if (line.startsWith("```")) {
-      return React.createElement(Text, { key: i, dimColor: true }, line);
-    }
-    // Heading
-    if (line.startsWith("### ")) {
-      return React.createElement(Text, { key: i, bold: true, color: "cyan" }, line.slice(4));
-    }
-    if (line.startsWith("## ")) {
-      return React.createElement(Text, { key: i, bold: true, color: "blue" }, line.slice(3));
-    }
-    if (line.startsWith("# ")) {
-      return React.createElement(Text, { key: i, bold: true, color: "magenta" }, line.slice(2));
-    }
-    // Bullet
+    if (line.startsWith("```")) return React.createElement(Text, { key: i, dimColor: true }, line);
+    if (line.startsWith("### ")) return React.createElement(Text, { key: i, bold: true, color: "cyan" }, line.slice(4));
+    if (line.startsWith("## ")) return React.createElement(Text, { key: i, bold: true, color: "blue" }, line.slice(3));
+    if (line.startsWith("# ")) return React.createElement(Text, { key: i, bold: true, color: "magenta" }, line.slice(2));
     if (line.startsWith("- ") || line.startsWith("* ")) {
-      return React.createElement(
-        Box, { key: i },
+      return React.createElement(Box, { key: i },
         React.createElement(Text, { color: "green" }, "  • "),
-        React.createElement(Text, null, line.slice(2))
-      );
+        React.createElement(Text, null, line.slice(2)));
     }
-    // Numbered
     if (/^\d+\.\s/.test(line)) {
       const match = line.match(/^(\d+\.\s)(.*)/);
-      return React.createElement(
-        Box, { key: i },
+      return React.createElement(Box, { key: i },
         React.createElement(Text, { color: "yellow" }, "  " + match[1]),
-        React.createElement(Text, null, match[2])
-      );
+        React.createElement(Text, null, match[2]));
     }
-    // Bold inline (very basic — whole line check)
     if (line.includes("**")) {
       const parts = line.split(/(\*\*[^*]+\*\*)/g);
-      const children = parts.map((p, j) => {
-        if (p.startsWith("**") && p.endsWith("**")) {
-          return React.createElement(Text, { key: j, bold: true }, p.slice(2, -2));
-        }
-        return React.createElement(Text, { key: j }, p);
-      });
+      const children = parts.map((p, j) =>
+        p.startsWith("**") && p.endsWith("**")
+          ? React.createElement(Text, { key: j, bold: true }, p.slice(2, -2))
+          : React.createElement(Text, { key: j }, p));
       return React.createElement(Box, { key: i }, ...children);
     }
-    // Horizontal rule
-    if (line.startsWith("---") || line.startsWith("===")) {
-      return React.createElement(Text, { key: i, dimColor: true }, "─".repeat(50));
-    }
-    // Empty line
-    if (line === "") {
-      return React.createElement(Newline, { key: i });
-    }
+    if (line.startsWith("---") || line.startsWith("===")) return React.createElement(Text, { key: i, dimColor: true }, "─".repeat(50));
+    if (line === "") return React.createElement(Newline, { key: i });
     return React.createElement(Text, { key: i }, line);
   });
 }
 
-// -----------------------------------------------------------------------
-// Cost tracking
-// -----------------------------------------------------------------------
-
-const MODEL_PRICING = {
-  "gemini-2.5-flash":         { input: 0.15,  output: 0.60 },
-  "gemini-2.5-pro":           { input: 1.25,  output: 10.0 },
-  "claude-sonnet-4-20250514": { input: 3.0,   output: 15.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 },
-  "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 },
-};
-
-function estimateCost(inputTokens, outputTokens, model) {
-  const pricing = MODEL_PRICING[model] ?? { input: 1.0, output: 3.0 };
-  const cost = (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
-  return { tokens: inputTokens + outputTokens, usd: cost };
-}
-
-function estimateTokens(text) {
-  return Math.ceil((text?.length ?? 0) / 4);
-}
-
-// -----------------------------------------------------------------------
-// Chat function (calls provider API)
-// -----------------------------------------------------------------------
-
-const OPENAI_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`,
-};
-
-// Simple tool set for TUI (subset of full REPL)
-const TUI_TOOL_DEFINITIONS = [
-  {
-    name: "read_file",
-    description: "Read a file",
-    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
-  },
-  {
-    name: "write_file",
-    description: "Write a file",
-    parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] },
-  },
-  {
-    name: "run_command",
-    description: "Run a shell command",
-    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] },
-  },
-  {
-    name: "list_directory",
-    description: "List directory contents",
-    parameters: { type: "object", properties: { path: { type: "string" } }, required: [] },
-  },
-  {
-    name: "git",
-    description: "Run git operations",
-    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] },
-  },
-  {
-    name: "web_search",
-    description: "Search the web",
-    parameters: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
-  },
-];
-
-async function executeTool(name, args) {
-  const { execFile } = await import("node:child_process");
-  const { promisify } = await import("node:util");
-  const execAsync = promisify(execFile);
-
-  try {
-    switch (name) {
-      case "read_file": {
-        const filePath = args.path.replace(/^~/, os.homedir());
-        const content = await readFile(filePath, "utf8");
-        return { success: true, content: content.length > 8000 ? content.slice(0, 8000) + "\n...(truncated)" : content };
-      }
-      case "write_file": {
-        const filePath = args.path.replace(/^~/, os.homedir());
-        await mkdir(path.dirname(filePath), { recursive: true });
-        await writeFile(filePath, args.content, "utf8");
-        return { success: true, message: `Written to ${filePath}` };
-      }
-      case "run_command": {
-        const { stdout, stderr } = await execAsync("/bin/bash", ["-c", args.command], {
-          timeout: 30000, maxBuffer: 1024 * 1024, cwd: process.cwd(),
-        });
-        const out = (stdout + (stderr ? `\nSTDERR: ${stderr}` : "")).trim();
-        return { success: true, output: out.length > 4000 ? out.slice(0, 4000) + "\n...(truncated)" : out };
-      }
-      case "list_directory": {
-        const { readdir } = await import("node:fs/promises");
-        const targetPath = (args.path || ".").replace(/^~/, os.homedir());
-        const entries = await readdir(targetPath, { withFileTypes: true });
-        return { success: true, listing: entries.map(e => `${e.isDirectory() ? "📁" : "📄"} ${e.name}`).join("\n") };
-      }
-      case "git": {
-        const { stdout, stderr } = await execAsync("/bin/bash", ["-c", `git ${args.command}`], {
-          timeout: 15000, cwd: process.cwd(),
-        });
-        return { success: true, output: (stdout + (stderr ? `\n${stderr}` : "")).trim().slice(0, 4000) };
-      }
-      case "web_search": {
-        const encoded = encodeURIComponent(args.query);
-        try {
-          const resp = await fetch(`https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1`, {
-            signal: AbortSignal.timeout(10000),
-          });
-          const data = await resp.json();
-          const results = data.RelatedTopics?.slice(0, 5).map(t => t.Text).filter(Boolean).join("\n\n");
-          return { success: true, results: results || "No results found" };
-        } catch (err) {
-          return { success: false, error: err.message };
-        }
-      }
-      default:
-        return { success: false, error: `Unknown tool: ${name}` };
-    }
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-
-async function callAPI(provider, apiKey, model, messages, onToolUse) {
-  if (provider === "google") {
-    return callGemini(apiKey, model, messages, onToolUse);
-  } else if (provider === "anthropic") {
-    return callAnthropic(apiKey, model, messages, onToolUse);
-  } else {
-    return callOpenAI(provider, apiKey, model, messages, onToolUse);
-  }
-}
-
-async function callGemini(apiKey, model, messages, onToolUse) {
-  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 tools = [{ functionDeclarations: TUI_TOOL_DEFINITIONS.map(t => ({ name: t.name, description: t.description, parameters: t.parameters })) }];
-  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
-
-  const resp = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      system_instruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
-      contents,
-      tools,
-      generationConfig: { temperature: 0.7, maxOutputTokens: 4096 },
-    }),
-  });
-
-  if (!resp.ok) {
-    const err = await resp.text();
-    throw new Error(`Gemini error ${resp.status}: ${err.slice(0, 200)}`);
-  }
-
-  const data = await resp.json();
-  const parts = data.candidates?.[0]?.content?.parts ?? [];
-  const fcs = parts.filter(p => p.functionCall);
-  if (fcs.length > 0) {
-    const calls = fcs.map(p => ({ name: p.functionCall.name, args: p.functionCall.args }));
-    for (const call of calls) {
-      onToolUse?.(call.name, call.args);
-      const result = await executeTool(call.name, call.args);
-      messages.push({ role: "assistant", toolCalls: [call], content: "" });
-      messages.push({ role: "tool_result", toolName: call.name, result });
-    }
-    return callGemini(apiKey, model, messages, onToolUse);
-  }
-
-  const text = parts.map(p => p.text ?? "").join("");
-  return text;
-}
-
-async function callAnthropic(apiKey, model, messages, onToolUse) {
-  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 tools = TUI_TOOL_DEFINITIONS.map(t => ({ name: t.name, description: t.description, input_schema: t.parameters }));
-
-  const resp = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: { "Content-Type": "application/json", "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
-    body: JSON.stringify({ model, max_tokens: 4096, system: systemPrompt, messages: anthropicMessages, tools }),
-  });
-
-  if (!resp.ok) {
-    const err = await resp.text();
-    throw new Error(`Anthropic error ${resp.status}: ${err.slice(0, 200)}`);
-  }
-
-  const data = await resp.json();
-  const toolUseBlocks = data.content?.filter(b => b.type === "tool_use") ?? [];
-  const textBlocks = data.content?.filter(b => b.type === "text") ?? [];
-
-  if (toolUseBlocks.length > 0) {
-    for (const block of toolUseBlocks) {
-      onToolUse?.(block.name, block.input);
-      const result = await executeTool(block.name, block.input);
-      messages.push({ role: "assistant", toolCalls: [{ id: block.id, name: block.name, args: block.input }], content: "" });
-      messages.push({ role: "tool_result", toolName: block.name, toolUseId: block.id, result });
-    }
-    return callAnthropic(apiKey, model, messages, onToolUse);
-  }
-
-  return textBlocks.map(b => b.text).join("");
-}
-
-async function callOpenAI(provider, apiKey, model, messages, onToolUse) {
-  const openaiMessages = messages
-    .filter(m => m.role !== "tool_result" || true) // keep all
-    .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 endpoint = OPENAI_ENDPOINTS[provider] ?? OPENAI_ENDPOINTS.openai;
-  const headers = { "Content-Type": "application/json" };
-  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
-
-  const tools = TUI_TOOL_DEFINITIONS.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
-
-  const resp = await fetch(endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ model, messages: openaiMessages, temperature: 0.7, max_tokens: 4096, tools }),
-  });
-
-  if (!resp.ok) {
-    const err = await resp.text();
-    throw new Error(`OpenAI error ${resp.status}: ${err.slice(0, 200)}`);
-  }
-
-  const data = await resp.json();
-  const choice = data.choices?.[0];
-  if (!choice) throw new Error("No response");
-
-  if (choice.message?.tool_calls?.length > 0) {
-    for (const tc of choice.message.tool_calls) {
-      const args = JSON.parse(tc.function.arguments);
-      onToolUse?.(tc.function.name, args);
-      const result = await executeTool(tc.function.name, args);
-      messages.push({ role: "assistant", toolCalls: [{ id: tc.id, name: tc.function.name, args }], content: "" });
-      messages.push({ role: "tool_result", toolName: tc.function.name, toolCallId: tc.id, result });
-    }
-    return callOpenAI(provider, apiKey, model, messages, onToolUse);
-  }
-
-  return choice.message?.content ?? "";
-}
-
 // -----------------------------------------------------------------------
 // TUI Components
 // -----------------------------------------------------------------------
 
-const SYSTEM_PROMPT = `You are Wispy 🌿 — a small ghost that lives in terminals.
-You float between code, files, and servers. Playful, honest, and curious.
-- Always use casual speech. Never formal.
-- End EVERY response with exactly one 🌿 emoji at the very end.
-- Reply in the same language the user writes in.
-- Be concise.
-Tools available: read_file, write_file, run_command, list_directory, git, web_search.`;
-
-// Status Bar Component
 function StatusBar({ provider, model, workstream, tokens, cost }) {
   const providerLabel = PROVIDERS[provider]?.label ?? provider ?? "?";
   const costStr = cost > 0 ? `$${cost.toFixed(4)}` : "$0.0000";
   const tokStr = tokens > 0 ? `${tokens}t` : "0t";
-  const ws = workstream ?? "default";
 
   return React.createElement(
-    Box, {
-      paddingX: 1,
-      backgroundColor: "blue",
-      width: "100%",
-    },
+    Box, { paddingX: 1, backgroundColor: "blue", width: "100%" },
     React.createElement(Text, { color: "white", bold: true }, "🌿 Wispy"),
     React.createElement(Text, { color: "white" }, "  "),
     React.createElement(Text, { color: "cyan" }, providerLabel),
     React.createElement(Text, { color: "white" }, " / "),
     React.createElement(Text, { color: "yellow" }, model ?? "?"),
     React.createElement(Text, { color: "white" }, "  ·  ws: "),
-    React.createElement(Text, { color: "green" }, ws),
+    React.createElement(Text, { color: "green" }, workstream ?? "default"),
     React.createElement(Text, { color: "white" }, "  ·  "),
     React.createElement(Text, { color: "white", dimColor: true }, `${tokStr} ${costStr}`),
   );
 }
 
-// Tool Execution Line
 function ToolLine({ name, args, result }) {
   const argsStr = Object.values(args ?? {}).join(", ").slice(0, 40);
-  const status = result
-    ? (result.success ? "✅" : "❌")
-    : "⏳";
-
+  const status = result ? (result.success ? "✅" : "❌") : "⏳";
   return React.createElement(
     Box, { paddingLeft: 2 },
-    React.createElement(Text, { color: "cyan", dimColor: true }, `${status} `),
-    React.createElement(Text, { color: "cyan", dimColor: true }, `🔧 ${name}`),
+    React.createElement(Text, { color: "cyan", dimColor: true }, `${status} 🔧 ${name}`),
     React.createElement(Text, { dimColor: true }, `(${argsStr})`),
-    result && !result.success
-      ? React.createElement(Text, { color: "red", dimColor: true }, ` — ${result.error?.slice(0, 60)}`)
-      : null,
   );
 }
 
-// Message Component
 function Message({ msg }) {
   if (msg.role === "user") {
     return React.createElement(
-      Box, { flexDirection: "column", marginY: 0, paddingLeft: 1 },
-      React.createElement(
-        Box, {},
+      Box, { flexDirection: "column", paddingLeft: 1 },
+      React.createElement(Box, {},
         React.createElement(Text, { color: "green", bold: true }, "› "),
-        React.createElement(Text, { color: "white" }, msg.content),
-      )
-    );
+        React.createElement(Text, { color: "white" }, msg.content)));
   }
-
   if (msg.role === "tool_call") {
     return React.createElement(ToolLine, { name: msg.name, args: msg.args, result: msg.result });
   }
-
   if (msg.role === "assistant") {
     return React.createElement(
       Box, { flexDirection: "column", paddingLeft: 1, marginTop: 0 },
-      React.createElement(
-        Box, { flexDirection: "column" },
+      React.createElement(Box, { flexDirection: "column" },
         React.createElement(Text, { color: "cyan", bold: true }, "🌿 "),
-        ...renderMarkdown(msg.content),
-      ),
-      React.createElement(Box, { height: 1 }),
-    );
+        ...renderMarkdown(msg.content)),
+      React.createElement(Box, { height: 1 }));
   }
-
   return null;
 }
 
-// Input Area Component
-function InputArea({ value, onChange, onSubmit, loading, disabled }) {
+function InputArea({ value, onChange, onSubmit, loading }) {
   return React.createElement(
-    Box, {
-      borderStyle: "single",
-      borderColor: loading ? "yellow" : "green",
-      paddingX: 1,
-      marginTop: 0,
-    },
+    Box, { borderStyle: "single", borderColor: loading ? "yellow" : "green", paddingX: 1 },
     loading
-      ? React.createElement(
-          Box, {},
+      ? React.createElement(Box, {},
           React.createElement(Spinner, { type: "dots" }),
-          React.createElement(Text, { color: "yellow" }, "  thinking..."),
-        )
-      : React.createElement(
-          Box, {},
+          React.createElement(Text, { color: "yellow" }, "  thinking..."))
+      : React.createElement(Box, {},
           React.createElement(Text, { color: "green" }, "› "),
           React.createElement(TextInput, {
-            value,
-            onChange,
-            onSubmit,
+            value, onChange, onSubmit,
             placeholder: "Type a message... (Ctrl+C to exit, /help for commands)",
-          }),
-        ),
-  );
+          })));
 }
 
-// Help overlay
-const HELP_TEXT = `
-Commands:
-  /clear      Reset conversation
-  /model X    Change model
-  /cost       Show token usage
-  /quit       Exit
-  /help       Show this help
-
-Keyboard:
-  Ctrl+C      Exit
-  Enter       Send message
-`;
-
+// -----------------------------------------------------------------------
 // Main App Component
-function WispyTUI({ providerInfo }) {
+// -----------------------------------------------------------------------
+
+function WispyTUI({ engine }) {
   const { exit } = useApp();
 
-  const [messages, setMessages] = useState([]); // display messages
+  const [messages, setMessages] = useState([]);
   const [inputValue, setInputValue] = useState("");
   const [loading, setLoading] = useState(false);
-  const [showHelp, setShowHelp] = useState(false);
+  const [model, setModel] = useState(engine.model ?? "?");
   const [totalTokens, setTotalTokens] = useState(0);
   const [totalCost, setTotalCost] = useState(0);
-  const [model, setModel] = useState(providerInfo?.model ?? "?");
 
-  // Conversation history for API
-  const conversationRef = useRef([
-    { role: "system", content: SYSTEM_PROMPT },
-  ]);
+  // Conversation history for persistence
+  const conversationRef = useRef([]);
 
-  // Load existing conversation on mount
   useEffect(() => {
     (async () => {
       const existing = await loadConversation();
       if (existing.length > 0) {
-        // Build display messages from saved conversation
-        const displayMsgs = existing
-          .filter(m => m.role === "user" || m.role === "assistant")
-          .slice(-20)
-          .map(m => ({ role: m.role, content: m.content }));
+        const displayMsgs = existing.filter(m => m.role === "user" || m.role === "assistant").slice(-20);
         setMessages(displayMsgs);
-
-        // Set conversation ref (with system prompt first)
-        conversationRef.current = [
-          { role: "system", content: SYSTEM_PROMPT },
-          ...existing.slice(-20),
-        ];
+        conversationRef.current = existing.slice(-20);
       }
     })();
   }, []);
@@ -633,141 +191,99 @@ function WispyTUI({ providerInfo }) {
   const handleSubmit = useCallback(async (value) => {
     const input = value.trim();
     if (!input || loading) return;
-
     setInputValue("");
 
-    // Handle slash commands
+    // Slash commands
     if (input.startsWith("/")) {
       const parts = input.split(/\s+/);
       const cmd = parts[0].toLowerCase();
-
-      if (cmd === "/quit" || cmd === "/exit") {
-        exit();
-        process.exit(0);
-        return;
-      }
+      if (cmd === "/quit" || cmd === "/exit") { exit(); process.exit(0); return; }
       if (cmd === "/clear") {
-        conversationRef.current = [{ role: "system", content: SYSTEM_PROMPT }];
+        conversationRef.current = [];
         setMessages([]);
         await saveConversation([]);
         setMessages([{ role: "assistant", content: "Conversation cleared. 🌿" }]);
         return;
       }
-      if (cmd === "/help") {
-        setShowHelp(h => !h);
-        return;
-      }
       if (cmd === "/cost") {
         setMessages(prev => [...prev, { role: "assistant", content: `Session: ${totalTokens} tokens (~$${totalCost.toFixed(4)}) 🌿` }]);
         return;
       }
       if (cmd === "/model" && parts[1]) {
+        engine.providers.setModel(parts[1]);
         setModel(parts[1]);
         setMessages(prev => [...prev, { role: "assistant", content: `Model changed to ${parts[1]} 🌿` }]);
         return;
       }
     }
 
-    // Add user message to display
     setMessages(prev => [...prev, { role: "user", content: input }]);
-
-    // Add to conversation
     conversationRef.current.push({ role: "user", content: input });
-
     setLoading(true);
 
     try {
-      const toolCallDisplay = [];
+      let responseText = "";
+
+      const result = await engine.processMessage(null, input, {
+        onChunk: (chunk) => {
+          // TUI doesn't stream to terminal, chunks are collected
+        },
+        onToolCall: (name, args) => {
+          const toolMsg = { role: "tool_call", name, args, result: null };
+          setMessages(prev => [...prev, toolMsg]);
+        },
+        noSave: true,
+      });
 
-      const onToolUse = (name, args) => {
-        const toolMsg = { role: "tool_call", name, args, result: null };
-        toolCallDisplay.push(toolMsg);
-        setMessages(prev => [...prev, toolMsg]);
+      responseText = result.content;
+
+      // Update token tracking
+      const { input: inputToks = 0, output: outputToks = 0 } = engine.providers.sessionTokens;
+      setTotalTokens(inputToks + outputToks);
+
+      // Estimate cost
+      const MODEL_PRICING = {
+        "gemini-2.5-flash": { input: 0.15, output: 0.60 },
+        "gemini-2.5-pro":   { input: 1.25, output: 10.0 },
+        "claude-sonnet-4-20250514": { input: 3.0, output: 15.0 },
+        "gpt-4o":           { input: 2.50, output: 10.0 },
+        "gpt-4.1":          { input: 2.0, output: 8.0 },
+        "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[model] ?? { input: 1.0, output: 3.0 };
+      const cost = (inputToks * pricing.input + outputToks * pricing.output) / 1_000_000;
+      setTotalCost(cost);
 
-      // Make a working copy of conversation to pass (API mutates for tool loops)
-      const convCopy = conversationRef.current.map(m => ({ ...m }));
-
-      const response = await callAPI(
-        providerInfo.provider,
-        providerInfo.key,
-        model,
-        convCopy,
-        (name, args) => {
-          onToolUse(name, args);
-        }
-      );
-
-      // Update token/cost estimates
-      const inputToks = estimateTokens(convCopy.map(m => m.content ?? "").join(""));
-      const outputToks = estimateTokens(response);
-      setTotalTokens(t => t + inputToks + outputToks);
-      const { usd } = estimateCost(inputToks, outputToks, model);
-      setTotalCost(c => c + usd);
-
-      // Update conversation ref with assistant response
-      conversationRef.current.push({ role: "assistant", content: response });
-
-      // Update tool call display results
-      setMessages(prev => {
-        const updated = [...prev];
-        // Mark tool calls as complete
-        for (let i = updated.length - 1; i >= 0; i--) {
-          if (updated[i].role === "tool_call" && updated[i].result === null) {
-            updated[i] = { ...updated[i], result: { success: true } };
-          }
-        }
-        return [...updated, { role: "assistant", content: response }];
-      });
-
-      // Save conversation
+      conversationRef.current.push({ role: "assistant", content: responseText });
+      setMessages(prev => [...prev, { role: "assistant", content: responseText }]);
       await saveConversation(conversationRef.current.filter(m => m.role !== "system"));
-
     } catch (err) {
-      setMessages(prev => [
-        ...prev,
-        { role: "assistant", content: `❌ Error: ${err.message.slice(0, 200)} 🌿` },
-      ]);
+      setMessages(prev => [...prev, { role: "assistant", content: `❌ Error: ${err.message.slice(0, 200)} 🌿` }]);
     } finally {
       setLoading(false);
     }
-  }, [loading, model, totalTokens, totalCost, providerInfo, exit]);
+  }, [loading, model, totalTokens, totalCost, engine, exit]);
 
-  // Keep only last N messages for display
   const displayMessages = messages.slice(-30);
 
   return React.createElement(
     Box, { flexDirection: "column", height: "100%" },
-
-    // Status bar
     React.createElement(StatusBar, {
-      provider: providerInfo?.provider,
+      provider: engine.provider,
       model,
       workstream: ACTIVE_WORKSTREAM,
       tokens: totalTokens,
       cost: totalCost,
     }),
-
-    // Help overlay
-    showHelp && React.createElement(
-      Box, { borderStyle: "round", borderColor: "yellow", marginX: 2, padding: 1 },
-      React.createElement(Text, { color: "yellow" }, HELP_TEXT.trim()),
-    ),
-
-    // Messages area (scrolls)
     React.createElement(
-      Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, paddingY: 0, overflowY: "hidden" },
+      Box, { flexDirection: "column", flexGrow: 1, paddingX: 1, overflowY: "hidden" },
       displayMessages.length === 0
-        ? React.createElement(
-            Box, { marginY: 1 },
-            React.createElement(Text, { dimColor: true }, "  🌿 Type a message to start chatting. /help for commands.")
-          )
-        : displayMessages.map((msg, i) =>
-            React.createElement(Message, { key: i, msg })
-          ),
+        ? React.createElement(Box, { marginY: 1 },
+            React.createElement(Text, { dimColor: true }, "  🌿 Type a message to start chatting. /help for commands."))
+        : displayMessages.map((msg, i) => React.createElement(Message, { key: i, msg })),
     ),
-
-    // Input area
     React.createElement(InputArea, {
       value: inputValue,
       onChange: setInputValue,
@@ -782,28 +298,29 @@ function WispyTUI({ providerInfo }) {
 // -----------------------------------------------------------------------
 
 async function main() {
-  // Check if stdin is a TTY
   if (!process.stdin.isTTY) {
     console.error("Error: wispy --tui requires a TTY terminal");
     process.exit(1);
   }
 
-  // Detect provider
-  const providerInfo = await detectProvider();
-  if (!providerInfo) {
+  // Initialize engine
+  const engine = new WispyEngine({ workstream: ACTIVE_WORKSTREAM });
+  const initResult = await engine.init();
+
+  if (!initResult) {
     console.error("No API key found. Run `wispy` first to set up your provider.");
     process.exit(1);
   }
 
-  // Clear screen
   process.stdout.write("\x1b[2J\x1b[H");
 
   const { waitUntilExit } = render(
-    React.createElement(WispyTUI, { providerInfo }),
+    React.createElement(WispyTUI, { engine }),
     { exitOnCtrlC: true }
   );
 
   await waitUntilExit();
+  engine.destroy();
 }
 
 main().catch(err => {