kafox-cli 0.10.2 → 0.10.4

package/README.md

@@ -85,6 +85,22 @@ conversa, com o texto por cima. Aceita **PNG** e **JPG**; a imagem e escurecida
 para nao atrapalhar a leitura e se ajusta sozinha ao tamanho do terminal.
 `/background off` remove, e a escolha fica em `~/.kafox/config.json`.
 
+## Colar imagem (Ctrl+V)
+
+Copie um print ou um recorte e aperte **Ctrl+V** na interface: a imagem entra
+como anexo do proximo turno, com preview dentro da caixa de texto, e vai junto
+com a mensagem para qualquer modelo com visao. Vale o mesmo limite do `/image`
+(3 por mensagem) — clique no ✕ do preview para tirar uma.
+
+A leitura usa o que existe na maquina: PowerShell no Windows, `pngpaste` (ou
+`osascript`) no macOS, `wl-paste` no Wayland e `xclip` no X11. Se nenhum estiver
+instalado, a CLI avisa e o `/image <arquivo>` continua funcionando.
+
+Alguns terminais consomem o Ctrl+V antes da CLI ver (o paste deles e
+`Ctrl+Shift+V`). Nesse caso use **`/paste`**, que le a area de transferencia do
+mesmo jeito. Sem imagem copiada, o Ctrl+V/`/paste` cola o texto, como um paste
+comum.
+
 ## Agentes e subagentes
 
 O agente tem a ferramenta `spawn_subagent`: ele lança subagentes com objetivo
@@ -106,7 +122,8 @@ Na interface: digite `/` para o menu (↑/↓ navega, Tab completa, Enter execut
 `/model` abre o seletor de modelo e `/theme` o de tema (↑/↓, clique do mouse,
 Enter aplica, Esc cancela). A resposta chega em streaming, com bloco `Thinking`
 quando o modelo manda o raciocinio. PgUp/PgDn ou a roda do mouse rolam a conversa;
-Ctrl+Y copia a ultima resposta e F2 solta o mouse para selecionar texto.
+Ctrl+Y copia a ultima resposta, Ctrl+V cola uma imagem copiada e F2 solta o
+mouse para selecionar texto.
 
 Enquanto o modelo trabalha a caixa de texto mostra `trabalhando...` com os
 pontinhos correndo, e o nome do modelo aparece fora dela, na linha de baixo.
@@ -122,8 +139,8 @@ o segundo interrompe o passo em andamento e guarda na conversa o que ja tinha
 chegado.
 
 Demais comandos: `/help`, `/models`, `/balance`, `/pricing`, `/key`, `/login`,
-`/logout`, `/whoami`, `/mcp`, `/allow`, `/theme`, `/background`, `/clear`,
-`/compact`, `/status`, `/exit`.
+`/logout`, `/whoami`, `/mcp`, `/allow`, `/theme`, `/background`, `/image`,
+`/paste`, `/clear`, `/compact`, `/status`, `/exit`.
 
 O `/theme` traz 29 temas (default, dark, light, brutalist, neon, paper,
 dracula, nord, gruvbox, monokai, tokyo-night, catppuccin, solarized, midnight,

package/package.json

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

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(" ");
@@ -58,6 +110,7 @@ async function handleCommand(line) {
       console.log(`  ${chalk.bold("Esc Esc")}  ${chalk.dim("para a IA na hora (o primeiro Esc avisa)")}`);
       console.log(`  ${chalk.bold("PgUp/PgDn")}  ${chalk.dim("ou a roda do mouse rola a conversa")}`);
       console.log(`  ${chalk.bold("Ctrl+Y")}  ${chalk.dim("copia a ultima resposta para a area de transferencia")}`);
+      console.log(`  ${chalk.bold("Ctrl+V")}  ${chalk.dim("cola uma imagem copiada (ou o texto) no proximo turno")}`);
       console.log(`  ${chalk.bold("F2")}  ${chalk.dim("solta o mouse para selecionar texto com o terminal")}`);
       console.log(`  ${chalk.bold("Ctrl+C")}  ${chalk.dim("sai")}`);
       console.log("");
@@ -178,6 +231,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`));
@@ -186,25 +240,39 @@ async function handleCommand(line) {
 }
 
 async function clearContext() {
+  // Guarda a conversa atual e comeca outra: manter o mesmo codigo fazia o
+  // que viesse depois do /clear cair no chat antigo (e ser sobrescrito por ele).
+  savePlainSession();
   history = [];
+  plainSession = { id: sessions.newId(), startedAt: new Date().toISOString() };
   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 +302,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 +363,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);
@@ -314,7 +442,13 @@ async function runREPL(options = {}) {
   }
 
   return runTUI({
-    commands: COMMANDS,
+    // /image e /paste so valem na interface: e ela que desenha o preview e
+    // manda a imagem junto da mensagem. O REPL sem TTY continua so texto.
+    commands: {
+      ...COMMANDS,
+      "/image": "anexa imagem ao proximo turno (/image <arquivo>; clear limpa)",
+      "/paste": "cola a imagem da area de transferencia (atalho: Ctrl+V)",
+    },
     onCommand: handleCommand,
     // /theme e /background rodam dentro da TUI; os demais abrem prompt no terminal.
     interactiveCommands: new Set(["/login", "/key"]),
@@ -332,5 +466,6 @@ module.exports = {
   clearContext,
   showStatus,
   handleCommand,
+  conversationMessages,
   COMMANDS,
 };

package/src/clipboard.js

@@ -0,0 +1,183 @@
+/**
+ * Area de transferencia: colar imagem no chat.
+ *
+ * O Ctrl+V do terminal so entrega texto. A imagem que voce copiou de um print
+ * (Win+Shift+S no Windows, Ctrl+Shift+Cmd+4 no macOS, "Copiar imagem" no Linux)
+ * nao passa por esse caminho, entao a CLI le a area de transferencia do sistema
+ * pelos utilitarios de sempre:
+ *
+ * - Windows: PowerShell (System.Windows.Forms.Clipboard)
+ * - macOS: `pngpaste` se estiver instalado, senao `osascript` com «class PNGf»
+ * - Linux: `wl-paste` (Wayland) e `xclip` (X11)
+ *
+ * Nada aqui lanca: sem utilitario instalado, a TUI recebe `{ ok: false }` com
+ * uma mensagem que diz o que instalar, e o `/image <arquivo>` continua valendo.
+ */
+const { spawnSync } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { sniffMime } = require("./images");
+
+// Ordem de preferencia: PNG e o formato que todos os provedores aceitam e o
+// unico que o preview desenha sem depender de dependencia opcional.
+const IMAGE_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+
+function run(command, args, options = {}) {
+  try {
+    const result = spawnSync(command, args, {
+      timeout: options.timeout || 6000,
+      windowsHide: true,
+      maxBuffer: 32 * 1024 * 1024,
+      input: options.input,
+    });
+    if (result.error) return { ok: false, reason: result.error.code || result.error.message };
+    if (result.status !== 0) return { ok: false, reason: `exit ${result.status ?? "?"}` };
+    const buffer = Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout || "");
+    if (!buffer.length) return { ok: false, reason: "vazio" };
+    return { ok: true, buffer };
+  } catch (error) {
+    return { ok: false, reason: error.message };
+  }
+}
+
+/**
+ * Escolhe o tipo de imagem na lista que o gerenciador de clipboard publica
+ * (`xclip -t TARGETS -o`, `wl-paste --list-types`). Uma imagem e anunciada por
+ * varios tipos; PNG ganha dos outros para a colagem sair igual em todo modelo.
+ */
+function pickMime(list) {
+  const text = String(list || "");
+  for (const mime of IMAGE_TYPES) {
+    if (text.includes(mime)) return mime;
+  }
+  return null;
+}
+
+function fromWayland() {
+  const types = run("wl-paste", ["--list-types"]);
+  if (!types.ok) return null;
+  const mime = pickMime(types.buffer.toString("utf8"));
+  if (!mime) return null;
+  const data = run("wl-paste", ["--no-newline", "--type", mime]);
+  if (!data.ok) return null;
+  return { buffer: data.buffer, mime };
+}
+
+function fromX11() {
+  const targets = run("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"]);
+  if (!targets.ok) return null;
+  const mime = pickMime(targets.buffer.toString("utf8"));
+  if (!mime) return null;
+  const data = run("xclip", ["-selection", "clipboard", "-t", mime, "-o"]);
+  if (!data.ok) return null;
+  return { buffer: data.buffer, mime };
+}
+
+function fromMac() {
+  const png = run("pngpaste", ["-"]);
+  if (png.ok && sniffMime(png.buffer)) return { buffer: png.buffer, mime: sniffMime(png.buffer) };
+
+  const file = path.join(os.tmpdir(), `kafox-paste-${process.pid}-${Date.now()}.png`);
+  const script = [
+    "set pngData to the clipboard as «class PNGf»",
+    `set f to open for access POSIX file "${file}" with write permission`,
+    "set eof f to 0",
+    "write pngData to f",
+    "close access f",
+  ];
+  const args = [];
+  for (const line of script) args.push("-e", line);
+
+  try {
+    if (!run("osascript", args).ok) return null;
+    const buffer = fs.readFileSync(file);
+    return buffer.length ? { buffer, mime: sniffMime(buffer) || "image/png" } : null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs.unlinkSync(file);
+    } catch {}
+  }
+}
+
+function fromWindows() {
+  const file = path.join(os.tmpdir(), `kafox-paste-${process.pid}-${Date.now()}.png`);
+  const script =
+    "Add-Type -AssemblyName System.Windows.Forms;" +
+    "Add-Type -AssemblyName System.Drawing;" +
+    "$img = [System.Windows.Forms.Clipboard]::GetImage();" +
+    "if ($img -eq $null) { exit 3 };" +
+    `$img.Save('${file.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png);`;
+
+  try {
+    if (!run("powershell", ["-NoProfile", "-NonInteractive", "-STA", "-Command", script]).ok) return null;
+    const buffer = fs.readFileSync(file);
+    return buffer.length ? { buffer, mime: sniffMime(buffer) || "image/png" } : null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs.unlinkSync(file);
+    } catch {}
+  }
+}
+
+function missingImageHint() {
+  if (process.platform === "darwin") {
+    return "nenhuma imagem copiada (copie um print com Ctrl+Shift+Cmd+4, ou use /image <arquivo>)";
+  }
+  if (process.platform === "win32") {
+    return "nenhuma imagem copiada (copie com Win+Shift+S, ou use /image <arquivo>)";
+  }
+  return "nenhuma imagem copiada (no Linux precisa de wl-clipboard ou xclip; /image <arquivo> sempre funciona)";
+}
+
+/**
+ * Le a imagem da area de transferencia.
+ * Retorna `{ ok: true, buffer, mime }` ou `{ ok: false, error }`.
+ */
+function readImage() {
+  const attempts =
+    process.platform === "win32"
+      ? [fromWindows]
+      : process.platform === "darwin"
+        ? [fromMac]
+        : [fromWayland, fromX11];
+
+  for (const attempt of attempts) {
+    let found = null;
+    try {
+      found = attempt();
+    } catch {
+      found = null;
+    }
+    if (found?.buffer?.length) {
+      return { ok: true, buffer: found.buffer, mime: sniffMime(found.buffer) || found.mime };
+    }
+  }
+
+  return { ok: false, error: missingImageHint() };
+}
+
+/** Le o texto da area de transferencia (fallback do Ctrl+V sem imagem). */
+function readText() {
+  const attempts =
+    process.platform === "win32"
+      ? [["powershell", ["-NoProfile", "-NonInteractive", "-Command", "Get-Clipboard -Raw"]]]
+      : process.platform === "darwin"
+        ? [["pbpaste", []]]
+        : [
+            ["wl-paste", ["--no-newline"]],
+            ["xclip", ["-selection", "clipboard", "-o"]],
+          ];
+
+  for (const [command, args] of attempts) {
+    const result = run(command, args);
+    if (result.ok) return result.buffer.toString("utf8");
+  }
+  return "";
+}
+
+module.exports = { IMAGE_TYPES, pickMime, readImage, readText };