kafox-cli 0.10.1 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kafox-cli",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "Kafox CLI: TUI com streaming, thinking, edit com diff, agent tools (files/shell), MCP e temas",
   "repository": {
     "type": "git",

package/src/auth.js

@@ -14,8 +14,10 @@ async function fetchApi(pathname, options = {}) {
       return await fetch(url, {
         ...options,
         headers: { ...storage.getAuthHeaders(options.headers), ...options.headers },
-        // timeout por tentativa: nao deixa um host travado segurar o login.
-        signal: AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined,
+        // Timeout por tentativa: nao deixa um host travado segurar o login.
+        // Mas se o caller passou o proprio signal (ex.: o stream do chat, que
+        // pode durar minutos), respeita ele em vez de matar em 12s.
+        signal: options.signal || (AbortSignal.timeout ? AbortSignal.timeout(12000) : undefined),
       });
     } catch (error) {
       lastError = error;

package/src/cli.js

@@ -4,8 +4,11 @@ const path = require("path");
 const inquirer = require("inquirer");
 const chalk = require("chalk");
 const storage = require("./storage");
+const promptHistory = require("./prompt-history");
 const { ensureSession, fetchApi } = require("./auth");
-const { ask } = require("./gateway");
+const { chat } = require("./gateway");
+const { compactIfNeeded, trimHistory } = require("./compact");
+const sessions = require("./sessions");
 const { runTUI } = require("./tui");
 const { runTheme, setContentBackground } = require("./theme");
 const { logoText, logoLines } = require("./logo");
@@ -38,12 +41,61 @@ const COMMANDS = {
 
 let history = [];
 let modelOverride = null;
+// Sessao do REPL sem TTY: e o que permite `kafox resume`/`kafox history`
+// acharem uma conversa usada por pipe, script ou CI (sem passar pela TUI).
+let plainSession = null;
 
 function pushHistory(role, content) {
   history.push({ role, content, at: new Date().toISOString() });
   if (history.length > 200) history = history.slice(-200);
 }
 
+/**
+ * Historico no formato OpenAI: e isso que vai para o provedor.
+ *
+ * Sem esse mapeamento o REPL sem TTY mandava so a linha digitada em cada
+ * requisicao, entao a IA respondia como se a conversa tivesse acabado de
+ * comecar. Mensagens seguidas do mesmo papel viram uma so (o provedor recusa
+ * duas em sequencia) e o system gerado pelo /compact e preservado.
+ */
+function conversationMessages(entries = history) {
+  const out = [];
+  for (const entry of entries) {
+    const role = String(entry?.role || "");
+    if (role !== "system" && role !== "user" && role !== "assistant") continue;
+    const content = String(entry?.content || "").trim();
+    if (!content) continue;
+    const last = out[out.length - 1];
+    if (last && last.role === role && role !== "system") last.content += `\n\n${content}`;
+    else out.push({ role, content });
+  }
+  return out;
+}
+
+/** Conversa visivel, no formato que `sessions.save` e `kafox history` leem. */
+function displayMessages() {
+  return history.map((entry) => ({ role: entry.role, text: entry.content }));
+}
+
+/** Grava a conversa do REPL sem TTY em ~/.kafox/chats (best-effort). */
+function savePlainSession() {
+  if (!plainSession) return;
+  try {
+    sessions.save({
+      id: plainSession.id,
+      cwd: process.cwd(),
+      model: modelOverride || storage.getConfig().model,
+      theme: storage.getConfig().theme,
+      allowAll: false,
+      messages: displayMessages(),
+      context: conversationMessages(),
+      startedAt: plainSession.startedAt,
+    });
+  } catch {
+    // Persistencia e conveniencia: falha de disco nao derruba o chat.
+  }
+}
+
 async function handleCommand(line) {
   const [cmd, ...rest] = line.trim().split(/\s+/);
   const arg = rest.join(" ");
@@ -178,6 +230,7 @@ async function handleCommand(line) {
       return true;
     case "/exit":
     case "/quit":
+      savePlainSession();
       process.exit(0);
     default:
       console.log(chalk.dim(`Unknown command: ${cmd}. Type /help`));
@@ -187,24 +240,35 @@ async function handleCommand(line) {
 
 async function clearContext() {
   history = [];
+  savePlainSession();
   console.log(chalk.green("Context cleared."));
 }
 
 async function compact() {
-  if (!history.length) {
+  const messages = conversationMessages();
+  if (!messages.length) {
     console.log(chalk.dim("Nothing to compact."));
     return;
   }
-  const turns = history.length;
-  const last = history.slice(-6);
-  history = [
-    {
-      role: "system",
-      content: `(context compacted: ${turns} messages summarized)`,
-      at: new Date().toISOString(),
-    },
-    ...last,
-  ];
+  const turns = messages.length;
+  // Mesmo resumo estruturado da TUI: o texto antigo vira nota de contexto em
+  // vez de sumir (o comportamento antigo so guardava um aviso vazio).
+  const result = await compactIfNeeded(messages, {
+    model: modelOverride || storage.getConfig().model,
+    // 0 forca o resumo: quem digitou /compact quer compactar agora.
+    thresholdTokens: 0,
+  });
+  if (!result.compacted) {
+    console.log(chalk.yellow(`Nothing to compact: ${result.error || "resumo vazio"}`));
+    return;
+  }
+  const at = new Date().toISOString();
+  history = result.messages.map((message) => ({
+    role: message.role,
+    content: String(message.content || ""),
+    at,
+  }));
+  savePlainSession();
   console.log(
     chalk.green(`Context compacted: ${turns} -> ${history.length} messages (auto summary).`)
   );
@@ -234,13 +298,40 @@ async function showStatus() {
 }
 
 /** Modo simples: sem TTY (scripts, pipes) ou apos o login. */
-async function runPlainREPL() {
+async function runPlainREPL(options = {}) {
   const cfg = storage.getConfig();
   const theme = cfg.theme || "default";
+  history = [];
+  plainSession = { id: sessions.newId(), startedAt: new Date().toISOString() };
+
+  // `kafox resume <codigo>` tambem vale sem TTY: antes o pipe/script abria
+  // sempre uma conversa vazia, mesmo com a sessao salva no disco.
+  if (options.resume) {
+    const wanted = options.resume === "pick" || options.resume === true ? "last" : options.resume;
+    const saved = String(wanted) === "last" ? sessions.latest() : sessions.find(wanted);
+    if (saved) {
+      plainSession = { id: saved.id, startedAt: saved.startedAt || plainSession.startedAt };
+      const restored =
+        Array.isArray(saved.context) && saved.context.length
+          ? saved.context
+          : sessions.contextFromMessages(saved.messages);
+      const at = new Date().toISOString();
+      history = restored
+        .filter((message) => ["system", "user", "assistant"].includes(message?.role))
+        .map((message) => ({ role: message.role, content: String(message.content || ""), at }));
+    } else {
+      console.log(chalk.yellow(`  Conversa ${wanted} nao encontrada - comecando uma nova.`));
+    }
+  }
 
   console.log(logoLines(theme).join("\n"));
   console.log(chalk.bold(`\n  Kafox CLI  v${VERSION}`));
   console.log(chalk.dim("  Type /help for commands. Ctrl+C to exit.\n"));
+  if (history.length) {
+    console.log(
+      chalk.dim(`  Retomando ${plainSession.id} (${conversationMessages().length} mensagens no contexto).`)
+    );
+  }
 
   const token = await ensureSession().catch(() => null);
   if (!token) {
@@ -268,35 +359,68 @@ async function runPlainREPL() {
     input: process.stdin,
     output: process.stdout,
     prompt: chalk.cyan("kafox> "),
+    // O readline guarda o mais recente no começo da lista.
+    history: promptHistory.load().slice().reverse(),
+    historySize: promptHistory.MAX,
+    removeHistoryDuplicates: true,
   });
 
-  rl.prompt();
-  rl.on("line", async (raw) => {
+  async function handleLine(raw) {
     const line = raw.trim();
-    if (!line) return rl.prompt();
+    if (!line) return;
     try {
       if (line.startsWith("/")) {
         await handleCommand(line);
       } else {
         pushHistory("user", line);
-        await ask(line, { model: modelOverride || storage.getConfig().model });
-        pushHistory("assistant", "(answer above)");
+        promptHistory.push(line);
+        // O historico inteiro (nao so a ultima linha) e o que faz a IA lembrar
+        // do que ja foi dito nesta conversa.
+        const result = await chat({
+          messages: trimHistory(conversationMessages()),
+          model: modelOverride || storage.getConfig().model,
+        });
+        if (!result.ok) {
+          console.log(chalk.red(`\n${result.error}`));
+        } else {
+          const answer = String(result.text || "").trim() || "(resposta vazia)";
+          console.log(chalk.green("\nAnswer:"));
+          console.log(answer);
+          pushHistory("assistant", answer);
+        }
+        savePlainSession();
       }
     } catch (err) {
       console.log(chalk.red(`\nError: ${err.message}`));
     }
-    rl.prompt();
+    if (!rl.closed) rl.prompt();
+  }
+
+  // Num pipe o stdin chega inteiro de uma vez: processar as linhas em paralelo
+  // embaralhava o historico (a segunda nao via a resposta da primeira).
+  let pending = Promise.resolve();
+  rl.prompt();
+  rl.on("line", (raw) => {
+    pending = pending.then(() => handleLine(raw));
+    return pending;
   });
 
-  rl.on("close", () => {
-    console.log(chalk.dim("\nSee you."));
+  rl.on("close", async () => {
+    // EOF do pipe nao pode cortar a ultima resposta no meio: antes o processo
+    // saia antes do POST /api/chat terminar e o chat ficava sem resposta.
+    await pending.catch(() => {});
+    savePlainSession();
+    if (plainSession && conversationMessages().length) {
+      console.log(chalk.dim(`\nConversa salva: kafox resume ${plainSession.id}`));
+    }
+    console.log(chalk.dim("See you."));
     process.exit(0);
   });
 }
 
 async function runREPL(options = {}) {
   // Sem TTY (pipe/CI), mantem o REPL linha a linha.
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return runPlainREPL();
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return runPlainREPL(options);
 
   const cfg = storage.getConfig();
   const token = await ensureSession().catch(() => null);
@@ -332,5 +456,6 @@ module.exports = {
   clearContext,
   showStatus,
   handleCommand,
+  conversationMessages,
   COMMANDS,
 };

package/src/gateway.js

@@ -117,7 +117,9 @@ function wait(ms, signal) {
       resolve(value);
     };
     const timer = setTimeout(() => done(true), ms);
-    timer.unref?.();
+    // Sem unref(): o backoff precisa manter o event loop vivo. Se este for o
+    // unico timer pendente e estiver unref'd, o Node dorme e a CLI so acorda
+    // quando o usuario digita algo — o retry ficaria "travado" ate um input.
     function onAbort() {
       done(false);
     }
@@ -139,7 +141,7 @@ function errorFrom(data, status) {
  * Le um stream SSE de chat completions (OpenAI-compatible) e chama os
  * callbacks a cada delta. Devolve o resultado final.
  */
-async function readStream({ response, started, onDelta, onReasoning }) {
+async function readStream({ response, started, onDelta, onReasoning, skipPrefix = "", signal } = {}) {
   const decoder = new TextDecoder();
   let buffer = "";
   let text = "";
@@ -147,6 +149,73 @@ async function readStream({ response, started, onDelta, onReasoning }) {
   let usage = null;
   const toolCalls = [];
 
+  // Watchdog de inatividade: o provedor as vezes morre sem FIN e o `for await`
+  // do body fica pendurado pra sempre (o event loop dorme e a CLI so acorda no
+  // proximo input). Se nenhum byte chega por IDLE_MS, aborta localmente e marca
+  // como retryable — o chat() reconecta por continuacao.
+  const IDLE_MS = Number(process.env.KAFOX_STREAM_IDLE_MS) || 90_000;
+  const idle = new AbortController();
+  let idleTimer = null;
+  let idleFired = false;
+  const clearIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = null;
+  };
+  // Quando o watchdog dispara, cancelamos o reader do body: isso desbloqueia o
+  // `read()` pendurado (o signal do fetch sozinho nao interrompe um body ja
+  // iniciado se a conexao morreu sem FIN).
+  let reader = null;
+  const onIdleAbort = () => {
+    idleFired = true;
+    reader?.cancel?.().catch(() => {});
+  };
+  idle.signal.addEventListener("abort", onIdleAbort, { once: true });
+  const bumpIdle = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => idle.abort(new Error("stream idle timeout")), IDLE_MS);
+  };
+  bumpIdle();
+  // Continuacao: o provedor costuma repetir o inicio ja recebido antes de
+  // seguir. Segura a emissao ate passar do prefixo para nao duplicar na tela.
+  let toSkip = skipPrefix;
+  // Texto efetivamente entregue ao onDelta nesta tentativa (sem o prefixo).
+  let emitted = "";
+
+  const emitContent = (chunk) => {
+    if (toSkip) {
+      if (chunk.length <= toSkip.length) {
+        // O trecho novo ainda esta dentro do prefixo repetido: confere se bate.
+        if (toSkip.startsWith(chunk)) {
+          toSkip = toSkip.slice(chunk.length);
+          return;
+        }
+        // Divergiu do prefixo: o modelo recomecou; emite tudo o que veio.
+        toSkip = "";
+        emitted += chunk;
+        onDelta?.(chunk);
+        return;
+      }
+      // Passou do prefixo: descarta a parte repetida e emite o resto.
+      const overlap = chunk.slice(0, toSkip.length);
+      if (overlap === toSkip || chunk.startsWith(toSkip)) {
+        const rest = chunk.slice(toSkip.length);
+        toSkip = "";
+        if (rest) {
+          emitted += rest;
+          onDelta?.(rest);
+        }
+        return;
+      }
+      // Nao bateu: recomecou, emite tudo.
+      toSkip = "";
+      emitted += chunk;
+      onDelta?.(chunk);
+      return;
+    }
+    emitted += chunk;
+    onDelta?.(chunk);
+  };
+
   const handleLine = (line) => {
     if (!line.startsWith("data:")) return null;
     const data = line.slice(5).trim();
@@ -172,48 +241,81 @@ async function readStream({ response, started, onDelta, onReasoning }) {
     }
     if (delta.content) {
       text += delta.content;
-      onDelta?.(delta.content);
+      emitContent(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 });
+    reader = response.body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bumpIdle();
+      buffer += decoder.decode(value, { 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, retryable: failure.retryable };
+        if (failure) { clearIdle(); return { ok: false, error: failure.error, retryable: failure.retryable }; }
         index = buffer.indexOf("\n");
       }
     }
     if (buffer.trim()) handleLine(buffer.trim());
+    // O cancel() do watchdog pode encerrar o reader como "done": se foi o
+    // watchdog que disparou, isso e falha e deve reconectar.
+    if (idleFired) {
+      clearIdle();
+      return {
+        ok: false,
+        error: `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`,
+        text,
+        emitted,
+        retryable: true,
+      };
+    }
   } catch (error) {
-    if (error?.name === "AbortError") {
-      return { ok: true, text, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+    clearIdle();
+    if (error?.name === "AbortError" || idleFired) {
+      // Abort com o signal do usuario ativo = ele apertou Esc: encerra.
+      if (signal?.aborted && !idleFired) {
+        return { ok: true, text, emitted, reasoning, toolCalls, ms: Date.now() - started, aborted: true };
+      }
+      // Sem abort do usuario, falha de conexao ou watchdog de inatividade:
+      // marca como retryable para o chat() reconectar de onde parou.
+      return {
+        ok: false,
+        error: idleFired
+          ? `Stream interrompido: sem resposta do provedor por ${Math.round(IDLE_MS / 1000)}s`
+          : `Stream interrompido: ${error.message || "conexao caiu"}`,
+        text,
+        emitted,
+        retryable: true,
+      };
     }
     return {
       ok: false,
       error: `Stream interrompido: ${error.message}`,
       text,
+      emitted,
       retryable: retryableMessage(error.message),
     };
   }
+  clearIdle();
 
-  return { ok: true, text, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
+  return { ok: true, text, emitted, reasoning, toolCalls: toolCalls.filter(Boolean), usage, ms: Date.now() - started };
 }
 
 /**
  * Uma tentativa no provedor kafox (gateway proprio): login/saldo/chave da conta
  * e POST em `/api/chat`.
  */
-async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptChat({ messages, model, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const socket = providerForModel(model);
   if (socket.provider.kind === "openai") {
-    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal });
+    return attemptOpenAI({ messages, model: socket.model, provider: socket.provider, tools, onDelta, onReasoning, signal, skipPrefix });
   }
 
   const ready = await ensureReady({ model });
@@ -235,11 +337,11 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
       keyCreated: ready.keyCreated,
     };
   }
@@ -254,7 +356,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model: ready.model, keyCreated: ready.keyCreated };
 }
 
@@ -263,7 +365,7 @@ async function attemptChat({ messages, model, tools, onDelta, onReasoning, signa
  * `{baseUrl}/chat/completions` com a chave do usuario. Sem login/saldo da conta
  * kafox; o custo e cobrado pelo proprio provedor.
  */
-async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal } = {}) {
+async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReasoning, signal, skipPrefix } = {}) {
   const apiKey = storage.getProviderKey(provider.id);
   if (!apiKey) {
     return {
@@ -292,11 +394,11 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
       signal,
     });
   } catch (error) {
-    if (error?.name === "AbortError") return { ok: false, code: "aborted", error: "Cancelado." };
+    if (error?.name === "AbortError" && signal?.aborted) return { ok: false, code: "aborted", error: "Cancelado." };
     return {
       ok: false,
-      error: `Falha de rede: ${error.message}`,
-      retryable: retryableMessage(error.message),
+      error: error?.name === "AbortError" ? `Falha de rede: ${error.message || "conexao caiu"}` : `Falha de rede: ${error.message}`,
+      retryable: error?.name === "AbortError" ? true : retryableMessage(error.message),
     };
   }
 
@@ -309,42 +411,93 @@ async function attemptOpenAI({ messages, model, provider, tools, onDelta, onReas
     };
   }
 
-  const result = await readStream({ response, started, onDelta, onReasoning });
+  const result = await readStream({ response, started, onDelta, onReasoning, skipPrefix, signal });
   return { ...result, model, provider: provider.id };
 }
 
 /**
  * Chat completions com stream (SSE) via /api/chat, com retry em falha de rede.
  * onRetry avisa a TUI (tentativa, espera) para ela mostrar a contagem.
+ *
+ * Queda no meio da resposta (o pior caso: ja saiu texto e o stream morre) e
+ * reconectada por continuacao: reenvia a conversa com o trecho parcial como
+ * assistant e pede para seguir de onde parou. O `skipPrefix` faz o provedor
+ * repetir o inicio; o gateway descarta a repeticao, entao a TUI so ve o que
+ * e novo. Se a continuacao falhar, devolve o parcial para nao perder nada.
  */
 async function chat({ messages, model, tools, onDelta, onReasoning, onRetry, signal, retries = RETRY_MAX } = {}) {
   const maxAttempts = Math.max(1, Number(retries) || RETRY_MAX);
   let attempt = 0;
   let last = null;
   let clearedKey = false;
+  // Acumulado entre tentativas (modo continuacao).
+  let carried = "";
+  let working = messages;
+  let skipPrefix = "";
 
   while (attempt < maxAttempts) {
     attempt += 1;
-    const result = await attemptChat({ messages, model, tools, onDelta, onReasoning, signal });
+    const result = await attemptChat({
+      messages: working,
+      model,
+      tools,
+      onDelta,
+      onReasoning,
+      signal,
+      skipPrefix,
+    });
 
-    if (result.ok || result.code === "aborted") return result;
+    if (result.ok || result.code === "aborted") {
+      if (carried && result.ok) {
+        // Junta o trecho das tentativas anteriores ao texto final.
+        const emitted = result.emitted ?? "";
+        const fullText = carried + emitted;
+        // Se o provedor mandou texto novo menor que o esperado, ainda vale o
+        // que ja foi mostrado; devolve o maior dos dois para o consumidor.
+        return { ...result, text: fullText.length >= (result.text || "").length ? fullText : result.text };
+      }
+      return result;
+    }
     if (result.code === "invalid_api_key" && !clearedKey) {
       clearedKey = true;
       storage.clearApiKey();
       continue;
     }
-    // Ja saiu texto: repetir duplicaria a resposta na tela.
-    if (!result.retryable || result.text) return result;
+    // Erro nao recuperavel (saldo, chave, modelo): devolve como veio.
+    if (!result.retryable) return carried ? { ...result, text: result.text || carried } : result;
     last = result;
 
+    // Caiu ja com texto na tela: reconecta continuando de onde parou.
+    const partial = String(result.text || "");
+    if (partial.trim()) {
+      carried += partial;
+      skipPrefix = carried;
+      working = [
+        ...messages,
+        { role: "assistant", content: carried },
+        {
+          role: "user",
+          content:
+            "Sua resposta anterior foi interrompida por uma falha de conexao. " +
+            "Continue exatamente de onde parou, sem repetir nada do que ja foi escrito.",
+        },
+      ];
+    }
+
     if (attempt >= maxAttempts) break;
 
     const delay = backoffMs(attempt);
     onRetry?.({ attempt, maxAttempts, delay, error: result.error });
     const slept = await wait(delay, signal);
-    if (!slept) return { ok: false, code: "aborted", error: "Cancelado.", keyCreated: result.keyCreated };
+    if (!slept) {
+      return { ok: false, code: "aborted", error: "Cancelado.", text: carried, keyCreated: result.keyCreated };
+    }
   }
 
+  // Esgotou as tentativas: se ja tinha texto, entrega o parcial (melhor que erro).
+  if (carried.trim()) {
+    return { ...last, ok: true, text: carried, attempts: attempt, partial: true };
+  }
   return { ...last, attempts: attempt };
 }