kafox-cli 0.2.3 → 0.6.0

package/src/gateway.js

@@ -3,26 +3,20 @@ const storage = require("./storage");
 const { ensureSession, fetchApi } = require("./auth");
 
 /**
- * Envia a pergunta ao gateway e devolve o resultado estruturado.
- * A TUI usa o retorno; o comando `kafox ask` so imprime.
+ * Garante sessao, saldo, modelo e chave antes de qualquer chamada.
+ * A chave `kafox_live_...` e da propria conta: o gateway cobra por ela.
  */
-async function askModel(question, options = {}) {
-  const text = typeof question === "string" ? question : (question || []).join(" ");
-  if (!text.trim()) {
-    return { ok: false, error: 'Usage: kafox ask "your question" [-m model]' };
-  }
-
+async function ensureReady(options = {}) {
   const token = await ensureSession();
   if (!token) {
     return { ok: false, error: "Login first: `kafox login`" };
   }
 
-  // Saldo decide se a CLI responde: sem credito, nem chega no gateway.
   const boot = await fetchApi("/api/bootstrap");
   if (!boot.ok) {
     return { ok: false, error: "Session invalid. Run `kafox login`" };
   }
-  const account = await boot.json();
+  const account = await boot.json().catch(() => null);
   const balance = Number(account?.user?.balance_micros || 0);
   if (balance <= 0) {
     return {
@@ -38,9 +32,7 @@ async function askModel(question, options = {}) {
       .then((response) => response.json())
       .catch(() => null);
     model = pricing?.pricing?.[0]?.model;
-    if (!model) {
-      return { ok: false, error: "Could not load model catalog." };
-    }
+    if (!model) return { ok: false, error: "Could not load model catalog." };
   }
 
   let keyCreated = false;
@@ -59,51 +51,152 @@ async function askModel(question, options = {}) {
     keyCreated = true;
   }
 
-  const response = await fetchApi("/api/public/playground", {
-    method: "POST",
-    body: JSON.stringify({ api_key: apiKey, model, message: text }),
-  });
-  const data = await response.json().catch(() => ({}));
+  return { ok: true, model, apiKey, keyCreated, balance };
+}
+
+function mergeToolCalls(target, deltas) {
+  for (const delta of deltas) {
+    const index = Number.isInteger(delta?.index) ? delta.index : target.length;
+    const current = target[index] || {
+      id: "",
+      type: "function",
+      function: { name: "", arguments: "" },
+    };
+    if (delta.id) current.id = delta.id;
+    if (delta.type) current.type = delta.type;
+    if (delta.function?.name) current.function.name += delta.function.name;
+    if (delta.function?.arguments) current.function.arguments += delta.function.arguments;
+    target[index] = current;
+  }
+}
+
+function errorFrom(data, status) {
+  const message =
+    data?.error?.message || data?.error || data?.body?.error?.message || `gateway error (${status})`;
+  return {
+    ok: false,
+    code: data?.code || (status === 402 ? "no_balance" : "gateway_error"),
+    error: String(message),
+  };
+}
+
+/**
+ * Chat completions com stream (SSE) via /api/chat.
+ * onDelta/onReasoning recebem o texto conforme chega; no fim devolve tudo junto.
+ */
+async function chat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+  const ready = await ensureReady({ model });
+  if (!ready.ok) return ready;
+
+  const started = Date.now();
+  let response;
+  try {
+    response = await fetchApi("/api/chat", {
+      method: "POST",
+      headers: { accept: "text/event-stream" },
+      body: JSON.stringify({
+        api_key: ready.apiKey,
+        model: ready.model,
+        messages,
+        tools: tools && tools.length ? tools : undefined,
+        stream: true,
+      }),
+      signal,
+    });
+  } catch (error) {
+    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    return { ok: false, error: `Falha de rede: ${error.message}` };
+  }
 
   if (!response.ok) {
-    if (response.status === 402) {
-      return {
-        ok: false,
-        code: "no_balance",
-        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
-      };
-    }
-    return { ok: false, error: `Failed: ${data.error || "gateway error"}` };
+    const data = await response.json().catch(() => ({}));
+    return { ...errorFrom(data, response.status), status: response.status, keyCreated: ready.keyCreated };
   }
 
-  // O playground devolve 200 mesmo quando o gateway recusa a chamada.
-  if (data.ok === false) {
-    const detail = data.body?.error?.message || data.body?.error || "gateway error";
-    if (data.status === 402) {
-      return {
-        ok: false,
-        code: "no_balance",
-        error: "Sem saldo para responder. Recarregue em https://kafox.pypag.com/dashboard",
-      };
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let text = "";
+  let reasoning = "";
+  let usage = null;
+  const toolCalls = [];
+
+  const handleLine = (line) => {
+    if (!line.startsWith("data:")) return null;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return null;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return null;
+    }
+    if (event?.error) {
+      return { error: event.error.message || String(event.error) };
+    }
+    if (event?.usage) usage = event.usage;
+    const delta = event?.choices?.[0]?.delta;
+    if (!delta) return null;
+    // Cada provedor manda o "pensamento" com um nome diferente.
+    const think = delta.reasoning_content ?? delta.reasoning ?? delta.thinking;
+    if (typeof think === "string" && think) {
+      reasoning += think;
+      onReasoning?.(think);
+    }
+    if (delta.content) {
+      text += delta.content;
+      onDelta?.(delta.content);
+    }
+    if (Array.isArray(delta.tool_calls)) mergeToolCalls(toolCalls, delta.tool_calls);
+    return null;
+  };
+
+  try {
+    for await (const chunk of response.body) {
+      buffer += decoder.decode(chunk, { stream: true });
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index).replace(/\r$/, "");
+        buffer = buffer.slice(index + 1);
+        const failure = handleLine(line);
+        if (failure) return { ok: false, error: failure.error };
+        index = buffer.indexOf("\n");
+      }
     }
-    return { ok: false, error: `Failed (${data.status}): ${detail}` };
+    if (buffer.trim()) handleLine(buffer.trim());
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      return { ok: true, text, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+    }
+    return { ok: false, error: `Stream interrompido: ${error.message}`, text };
   }
 
-  const body = data.body;
-  const output =
-    typeof body === "string"
-      ? body
-      : body?.choices?.[0]?.message?.content ||
-        body?.choices?.[0]?.text ||
-        JSON.stringify(body, null, 2);
+  return {
+    ok: true,
+    text,
+    reasoning,
+    toolCalls: toolCalls.filter(Boolean),
+    usage,
+    ms: Date.now() - started,
+    model: ready.model,
+    keyCreated: ready.keyCreated,
+    provider: response.headers?.get?.("x-kafox-provider") || "",
+  };
+}
 
+/** Compatibilidade: resposta unica, sem callbacks (usada por `kafox ask`). */
+async function askModel(question, options = {}) {
+  const text = typeof question === "string" ? question : (question || []).join(" ");
+  if (!text.trim()) {
+    return { ok: false, error: 'Usage: kafox ask "your question" [-m model]' };
+  }
+  const result = await chat({ messages: [{ role: "user", content: text }], model: options.model });
+  if (!result.ok) return result;
   return {
     ok: true,
-    text: String(output || "").trim() || "(resposta vazia)",
-    ms: data.ms,
-    provider: data.provider,
-    model,
-    keyCreated,
+    text: String(result.text || "").trim() || "(resposta vazia)",
+    ms: result.ms,
+    model: result.model,
+    keyCreated: result.keyCreated,
   };
 }
 
@@ -124,4 +217,4 @@ async function ask(question, options = {}) {
   }
 }
 
-module.exports = { ask, askModel };
+module.exports = { ask, askModel, chat, ensureReady, mergeToolCalls };

package/src/logo.js

@@ -0,0 +1,108 @@
+/**
+ * Logo do kafox: a arte "KAFOX" em blocos (fundo azul), adaptada por tema.
+ *
+ * A arte original vem com codigos ANSI por trecho; aqui ela e decodificada em
+ * segmentos {fg, bg, texto} e repintada com chalk, para que o fundo do tema
+ * entre nos espacos transparentes e o texto continue legivel no tema claro.
+ */
+const chalk = require("chalk");
+const { themeColors } = require("./theme");
+
+const SGR = /\x1b\[([0-9;]*)m/g;
+
+// Paleta da arte. 97 = tinta clara, 94 = azul, 34 = azul fundo, 37 = neutro,
+// 44 = fundo azul (aplicado junto de 94).
+const PALETTES = {
+  dark: { ink: "#ffffff", gray: "#c8c8c8", blue: "#3f6ef0", deep: "#1c2fc4", fill: "#1c2fc4" },
+  light: { ink: "#2323b8", gray: "#6f6f6f", blue: "#4b52e8", deep: "#2a2ab0", fill: "#c7cfff" },
+};
+
+const STYLE_KEYS = {
+  37: { fg: "gray" },
+  34: { fg: "deep" },
+  94: { fg: "blue" },
+  97: { fg: "ink" },
+  44: { bg: "fill" },
+};
+
+const RAW_LOGO = [
+  "\x1b[0;97m█\x1b[0;94m█\x1b[0;94;44m▓▓\x1b[0;37m  \x1b[0;94;44m█▓▒░\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m███▄\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m████\x1b[0;37m \x1b[0;97m▄\x1b[0;94m█\x1b[0;94;44m▓▓▒░\x1b[0;34m███▄\x1b[0;37m \x1b[0;97m█\x1b[0;94m█\x1b[0;94;44m▓▓\x1b[0;37m  \x1b[0;94;44m▓▒░\x1b[0;34m█\x1b[0m",
+  "\x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;94;44m▓▒░\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m \x1b[0;34m██\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m░░\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m▓▓▒▒\x1b[0;37m  \x1b[0;94;44m▒░░\x1b[0;34m█\x1b[0m",
+  "\x1b[0;94;44m▒▒░░\x1b[0;34m█\x1b[0;94;44m░▒░▒\x1b[0;34m▄\x1b[0;37m \x1b[0;94;44m▒▒░░\x1b[0;34m██████\x1b[0;37m \x1b[0;94;44m▒▒░░\x1b[0;34m█\x1b[0;37m      \x1b[0;94;44m▒▒░░\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▒▒\x1b[0;34m█\x1b[0;37m \x1b[0;94m▀\x1b[0;94;44m▒░░\x1b[0;34m██\x1b[0;94;44m░▒▒\x1b[0;94m▀\x1b[0m",
+  "\x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;94;44m░▓▓ \x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓\x1b[0;34m█\x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m       \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓ \x1b[0;37m \x1b[0;94;44m░░\x1b[0;34m██\x1b[0;37m  \x1b[0;34m█\x1b[0;94;44m▓▓ \x1b[0m",
+  "\x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0;37m \x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0;37m \x1b[0;34m████\x1b[0;37m       \x1b[0;34m▀████████▀\x1b[0;37m \x1b[0;34m████\x1b[0;37m  \x1b[0;34m████\x1b[0m",
+];
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+/** Decodifica uma linha crua em segmentos com estilo e texto. */
+function parseLine(raw) {
+  const segments = [];
+  let style = { fg: null, bg: null };
+  let last = 0;
+  let match;
+  SGR.lastIndex = 0;
+
+  while ((match = SGR.exec(raw)) !== null) {
+    if (match.index > last) {
+      segments.push({ ...style, text: raw.slice(last, match.index) });
+    }
+    const codes = match[1].split(";").filter(Boolean).map(Number);
+    for (const code of codes) {
+      if (code === 0) style = { fg: null, bg: null };
+      else if (STYLE_KEYS[code]) Object.assign(style, STYLE_KEYS[code]);
+    }
+    last = match.index + match[0].length;
+  }
+  if (last < raw.length) segments.push({ ...style, text: raw.slice(last) });
+  return segments;
+}
+
+const SEGMENTS = RAW_LOGO.map(parseLine);
+
+const LOGO_TEXT = SEGMENTS.map((line) => line.map((part) => part.text).join(""));
+const LOGO_WIDTH = Math.max(...LOGO_TEXT.map((line) => line.length));
+const LOGO_HEIGHT = LOGO_TEXT.length;
+
+/** Temas de fundo claro precisam de tinta escura para o desenho nao sumir. */
+function paletteFor(theme) {
+  const { bg } = themeColors(theme);
+  if (!bg) return PALETTES.dark;
+  const [r, g, b] = [1, 3, 5].map((index) => parseInt(bg.slice(index, index + 2), 16));
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance > 0.6 ? PALETTES.light : PALETTES.dark;
+}
+
+function paintSegment(text, style, palette) {
+  if (!text) return "";
+  const fg = style.fg ? palette[style.fg] : null;
+  const bg = style.bg ? palette[style.bg] : null;
+  if (fg && bg) return chalk.bgHex(bg).hex(fg)(text);
+  if (bg) return chalk.bgHex(bg)(text);
+  if (fg) return chalk.hex(fg)(text);
+  return text;
+}
+
+/** Linhas da arte ja coloridas (sem a cor de fundo da tela). */
+function logoLines(theme = "default") {
+  const palette = paletteFor(theme);
+  return SEGMENTS.map((segments) =>
+    segments.map((part) => paintSegment(part.text, part, palette)).join("")
+  );
+}
+
+/** Versao em texto puro (sem cor), para saidas nao-TTY e testes. */
+function logoText() {
+  return LOGO_TEXT.join("\n");
+}
+
+module.exports = {
+  logoLines,
+  logoText,
+  parseLine,
+  LOGO_WIDTH,
+  LOGO_HEIGHT,
+  PALETTES,
+  paletteFor,
+  stripAnsi: (value) => String(value).replace(ANSI_RE, ""),
+};

package/src/mascot.js

@@ -1,32 +1,4 @@
-// Kafox mascot art (ASCII only, no accents).
-const MASCOT = [
-  "████                      ████",
-  "  ▒▒░░░░▓▓                  ▓▓░░░░▒▒",
-  "  ██░░▒▒░░██              ██░░▒▒░░██",
-  "  ██░░▓▓▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒▓▓░░██",
-  "  ██░░▓▓▓▓▒▒▓▓          ▓▓▒▒▓▓▓▓░░██",
-  "  ██░░▒▒▒▒▓▓░░░░░░░░░░░░░░▓▓▒▒▒▒░░██",
-  "  ██▒▒▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓▒▒██",
-  "▒▒  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ▓▓",
-  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
-  "██  ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  ██",
-  "██  ░░▓▓▓▓░░░░░░░░░░░░░░░░░░▓▓▓▓░░  ██",
-  "██  ░░░░░░▓▓░░░░░░▒▒░░░░░░▓▓░░░░░░  ██",
-  "██░░░░░░░░░░▓▓░░▒▒▒▒▒▒░░▓▓░░░░░░░░░░██",
-  "██░░        ░░░░░░░░░░░░░░        ░░██    ▒▒▓▓",
-  "  ██            ▓▓▓▓▓▓            ██    ██  ██",
-  "    ▓▓            ▓▓            ▓▓  ▓▓▒▒    ██",
-  "      ██        ▓▓  ▓▓        ██  ██        ██",
-  "        ▓▓▓▓              ▓▓▓▓  ▓▓░░░░      ██",
-  "      ██▒▒░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▒▒██░░▒▒▒▒░░░░░░██",
-  "      ██░░░░              ░░░░▓▓▒▒▒▒▒▒▒▒░░░░██",
-  "    ██░░░░░░              ░░░░░░▓▓▒▒▒▒▒▒░░██",
-  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒▒▒▒▒▓▓",
-  "    ██░░░░  ▒▒          ▒▒  ░░░░▓▓▒▒████",
-  "    ██▒▒░░  ▓▓    ▒▒    ▓▓  ░░▒▒██▓▓",
-  "      ████  ▓▓    ▓▓    ▓▓  ████",
-  "          ▒▒██▓▓  ▓▓  ▓▓██▒▒",
-  "              ██████████",
-].join("\n");
+// Compatibilidade: o "mascote" agora e o logo KAFOX em blocos (logo.js).
+const { logoText, logoLines } = require("./logo");
 
-module.exports = { mascot: MASCOT };
+module.exports = { mascot: logoText(), logoLines };