kafox-cli 0.10.2 → 0.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kafox-cli",
-  "version": "0.10.2",
+  "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/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/images.js

@@ -0,0 +1,341 @@
+/**
+ * Anexos de imagem do kafox.
+ *
+ * - carrega arquivos (png/jpg/gif/webp) do disco ou de bytes colados
+ * - decodifica para RGBA e gera um preview "pixelado" em blocos, no estilo
+ *   dos terminais graficos: cada celula de caractere cobre 2 pixels verticais
+ *   usando o glifo de meio bloco (▀) e as cores de verdadeiro color.
+ * - o preview e o que a TUI desenha dentro da caixa de input; a imagem
+ *   completa (base64) vai no payload multimodal enviado ao modelo.
+ */
+const fs = require("fs");
+const path = require("path");
+
+let jpegDecode = null;
+try {
+  // Dep opcional: se nao existir, JPEG fica indisponivel mas PNG continua.
+  jpegDecode = require("jpeg-js").decode;
+} catch {
+  jpegDecode = null;
+}
+
+const MAX_IMAGES = 3;
+const MAX_BYTES = 12 * 1024 * 1024; // 12 MB por arquivo
+const MAX_PREVIEW_COLS = 44;
+const MAX_PREVIEW_ROWS = 10; // em celulas (cada celula = 2 pixels de altura)
+
+const MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+};
+
+/* ------------------------------------------------------------- decodificacao */
+
+function sniffMime(buffer) {
+  if (buffer.length >= 8 && buffer.readUInt32BE(0) === 0x89504e47) return "image/png";
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return "image/jpeg";
+  if (buffer.length >= 6 && buffer.slice(0, 6).toString("ascii") === "GIF87a") return "image/gif";
+  if (buffer.length >= 6 && buffer.slice(0, 6).toString("ascii") === "GIF89a") return "image/gif";
+  if (buffer.length >= 12 && buffer.slice(0, 4).toString("ascii") === "RIFF" && buffer.slice(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return null;
+}
+
+function decodePng(buffer) {
+  const signature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+  if (!buffer.slice(0, 8).equals(signature)) throw new Error("PNG inválido");
+
+  const { inflateSync } = require("zlib");
+  let offset = 8;
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  const idat = [];
+
+  while (offset + 8 <= buffer.length) {
+    const length = buffer.readUInt32BE(offset);
+    const type = buffer.slice(offset + 4, offset + 8).toString("ascii");
+    const data = buffer.slice(offset + 8, offset + 8 + length);
+    offset += 12 + length;
+
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      depth = data[8];
+      colorType = data[9];
+      interlace = data[12];
+    } else if (type === "IDAT") {
+      idat.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+  }
+
+  if (!width || !height) throw new Error("PNG sem cabeçalho IHDR");
+  if (depth !== 8) throw new Error("PNG com profundidade não suportada");
+  if (interlace !== 0) throw new Error("PNG entrelaçado não suportado");
+
+  const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType];
+  if (!channels) throw new Error("PNG com color type não suportado");
+
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * channels;
+  const out = Buffer.alloc(width * height * 4);
+
+  let prev = Buffer.alloc(stride);
+  let cursor = 0;
+
+  for (let y = 0; y < height; y += 1) {
+    const filter = raw[cursor];
+    cursor += 1;
+    const line = Buffer.from(raw.slice(cursor, cursor + stride));
+    cursor += stride;
+
+    for (let x = 0; x < stride; x += 1) {
+      const a = x >= channels ? line[x - channels] : 0;
+      const b = prev[x];
+      const c = x >= channels ? prev[x - channels] : 0;
+      switch (filter) {
+        case 1:
+          line[x] = (line[x] + a) & 0xff;
+          break;
+        case 2:
+          line[x] = (line[x] + b) & 0xff;
+          break;
+        case 3:
+          line[x] = (line[x] + ((a + b) >> 1)) & 0xff;
+          break;
+        case 4: {
+          const p = a + b - c;
+          const pa = Math.abs(p - a);
+          const pb = Math.abs(p - b);
+          const pc = Math.abs(p - c);
+          const pred = pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+          line[x] = (line[x] + pred) & 0xff;
+          break;
+        }
+        default:
+          break;
+      }
+    }
+
+    for (let x = 0; x < width; x += 1) {
+      const src = x * channels;
+      const dst = (y * width + x) * 4;
+      if (colorType === 0) {
+        const gray = line[src];
+        out[dst] = gray;
+        out[dst + 1] = gray;
+        out[dst + 2] = gray;
+        out[dst + 3] = 255;
+      } else if (colorType === 2) {
+        out[dst] = line[src];
+        out[dst + 1] = line[src + 1];
+        out[dst + 2] = line[src + 2];
+        out[dst + 3] = 255;
+      } else if (colorType === 4) {
+        out[dst] = line[src];
+        out[dst + 1] = line[src];
+        out[dst + 2] = line[src];
+        out[dst + 3] = line[src + 1];
+      } else {
+        out[dst] = line[src];
+        out[dst + 1] = line[src + 1];
+        out[dst + 2] = line[src + 2];
+        out[dst + 3] = line[src + 3];
+      }
+    }
+
+    prev = line;
+  }
+
+  return { width, height, data: out };
+}
+
+function decodeImage(buffer, mime) {
+  const kind = mime || sniffMime(buffer);
+  if (kind === "image/png") return decodePng(buffer);
+  if (kind === "image/jpeg") {
+    if (!jpegDecode) throw new Error("JPEG requer a dependência jpeg-js");
+    const decoded = jpegDecode(buffer, { useTArray: true, maxMemoryUsageInMB: 512 });
+    // jpeg-js pode devolver RGB sem alfa; normaliza para RGBA.
+    if (decoded.data.length === decoded.width * decoded.height * 4) {
+      return { width: decoded.width, height: decoded.height, data: Buffer.from(decoded.data) };
+    }
+    const data = Buffer.alloc(decoded.width * decoded.height * 4);
+    for (let i = 0, j = 0; i < decoded.data.length; i += 3, j += 4) {
+      data[j] = decoded.data[i];
+      data[j + 1] = decoded.data[i + 1];
+      data[j + 2] = decoded.data[i + 2];
+      data[j + 3] = 255;
+    }
+    return { width: decoded.width, height: decoded.height, data };
+  }
+  throw new Error(`formato não suportado: ${kind || "desconhecido"}`);
+}
+
+/* --------------------------------------------------------------- pixelizacao */
+
+function sampleBox(img, x0, y0, x1, y1) {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let a = 0;
+  let n = 0;
+  const left = Math.max(0, Math.floor(x0));
+  const right = Math.min(img.width, Math.max(left + 1, Math.ceil(x1)));
+  const top = Math.max(0, Math.floor(y0));
+  const bottom = Math.min(img.height, Math.max(top + 1, Math.ceil(y1)));
+
+  for (let y = top; y < bottom; y += 1) {
+    for (let x = left; x < right; x += 1) {
+      const i = (y * img.width + x) * 4;
+      const alpha = img.data[i + 3] / 255;
+      // Composicao sobre branco: assim imagem com transparencia nao fica preta.
+      r += img.data[i] * alpha + 255 * (1 - alpha);
+      g += img.data[i + 1] * alpha + 255 * (1 - alpha);
+      b += img.data[i + 2] * alpha + 255 * (1 - alpha);
+      a += img.data[i + 3];
+      n += 1;
+    }
+  }
+
+  if (!n) return { r: 0, g: 0, b: 0, a: 0 };
+  return { r: r / n, g: g / n, b: b / n, a: a / n };
+}
+
+/**
+ * Gera o preview pixelado. Usa meio bloco: um caractere = 2 pixels empilhados,
+ * entao a quantidade de linhas de texto e metade dos pixels amostrados.
+ */
+function pixelate(img, { cols = MAX_PREVIEW_COLS, rows = MAX_PREVIEW_ROWS } = {}) {
+  const cellRows = clampNumber(rows, 1, 40);
+  const cellCols = clampNumber(cols, 4, 120);
+  const pxHigh = cellRows * 2;
+
+  const scale = Math.min(cellCols / img.width, pxHigh / img.height);
+  const drawW = Math.max(1, Math.round(img.width * scale));
+  const drawH = Math.max(1, Math.round(img.height * scale));
+  const offX = Math.floor((cellCols - drawW) / 2);
+  const offY = Math.floor((pxHigh - drawH) / 2);
+
+  const grid = [];
+  for (let y = 0; y < pxHigh; y += 1) {
+    const row = [];
+    for (let x = 0; x < cellCols; x += 1) {
+      const inside = x >= offX && x < offX + drawW && y >= offY && y < offY + drawH;
+      if (!inside) {
+        row.push(null);
+        continue;
+      }
+      const sx0 = ((x - offX) / drawW) * img.width;
+      const sy0 = ((y - offY) / drawH) * img.height;
+      row.push(sampleBox(img, sx0, sy0, sx0 + img.width / drawW, sy0 + img.height / drawH));
+    }
+    grid.push(row);
+  }
+
+  const lines = [];
+  for (let y = 0; y < grid.length; y += 2) {
+    let out = "";
+    for (let x = 0; x < cellCols; x += 1) {
+      const top = grid[y][x];
+      const bottom = grid[y + 1] ? grid[y + 1][x] : null;
+      if (!top && !bottom) {
+        out += " ";
+        continue;
+      }
+      const fg = top || bottom;
+      const bg = bottom || top;
+      out += `\x1b[38;2;${Math.round(fg.r)};${Math.round(fg.g)};${Math.round(fg.b)}m` +
+        `\x1b[48;2;${Math.round(bg.r)};${Math.round(bg.g)};${Math.round(bg.b)}m▀\x1b[0m`;
+    }
+    lines.push(out);
+  }
+
+  return { lines, width: cellCols, height: pxHigh };
+}
+
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+/* ------------------------------------------------------------------- anexos */
+
+function mimeFor(file) {
+  return MIME_BY_EXT[path.extname(file).toLowerCase()] || null;
+}
+
+/**
+ * Carrega uma imagem do disco e monta o anexo usado pela TUI.
+ * Retorna `{ ok, attachment }` ou `{ ok: false, error }` — nunca lanca.
+ */
+function loadImage(file, options = {}) {
+  const target = path.resolve(file);
+  let buffer;
+  try {
+    const stat = fs.statSync(target);
+    if (!stat.isFile()) return { ok: false, error: "não é um arquivo" };
+    if (stat.size > (options.maxBytes || MAX_BYTES)) {
+      return { ok: false, error: "arquivo maior que 12 MB" };
+    }
+    buffer = fs.readFileSync(target);
+  } catch (error) {
+    return { ok: false, error: `não consegui abrir (${error.code || error.message})` };
+  }
+  return buildAttachment(buffer, { name: path.basename(target), mime: mimeFor(target) || sniffMime(buffer), ...options });
+}
+
+/** Monta o anexo a partir de bytes ja em memoria (colagem/arrastar). */
+function buildAttachment(buffer, { name = "imagem", mime, cols, rows } = {}) {
+  const kind = mime || sniffMime(buffer);
+  if (!kind) return { ok: false, error: "formato de imagem não reconhecido" };
+
+  let decoded;
+  try {
+    decoded = decodeImage(buffer, kind);
+  } catch (error) {
+    return { ok: false, error: `não consegui decodificar (${error.message})` };
+  }
+
+  const preview = pixelate(decoded, { cols, rows });
+  return {
+    ok: true,
+    attachment: {
+      name,
+      mime: kind,
+      bytes: buffer.length,
+      width: decoded.width,
+      height: decoded.height,
+      dataUrl: `data:${kind};base64,${buffer.toString("base64")}`,
+      preview: preview.lines,
+      previewWidth: preview.width,
+    },
+  };
+}
+
+function humanSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+module.exports = {
+  MAX_IMAGES,
+  MAX_BYTES,
+  MAX_PREVIEW_COLS,
+  MAX_PREVIEW_ROWS,
+  sniffMime,
+  decodeImage,
+  pixelate,
+  loadImage,
+  buildAttachment,
+  humanSize,
+};

package/src/mobile/index.js

@@ -270,7 +270,7 @@ async function runMobile({
     sessionId: saved?.id || sessions.newId(),
     sessionStartedAt: saved?.startedAt || new Date().toISOString(),
     messages: saved?.messages || [],
-    context: saved?.context || [],
+    context: saved?.context?.length ? saved.context : sessions.contextFromMessages(saved?.messages),
     model: saved?.model || null,
     allowAll: allowAll || Boolean(saved?.allowAll),
   });

package/src/prompt-history.js

@@ -0,0 +1,64 @@
+/**
+ * Histórico de linhas digitadas no terminal (setas ↑/↓).
+ *
+ * É separado das conversas salvas em ~/.kafox/chats: aqui ficam só os prompts
+ * recentes, para reaproveitar uma pergunta sem precisar decorar. O arquivo é
+ * privado (0600) e tem teto de 200 linhas para não crescer sem limite.
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const storage = require("./storage");
+
+const MAX = 200;
+const FILE = "history.json";
+
+function baseDir(dir) {
+  return dir || storage.DIR || path.join(os.homedir(), ".kafox");
+}
+
+function filePath(dir) {
+  return path.join(baseDir(dir), FILE);
+}
+
+function sanitize(list) {
+  return (Array.isArray(list) ? list : [])
+    .filter((item) => typeof item === "string" && item.trim())
+    .map((item) => item.replace(/\r/g, "").trim())
+    .slice(-MAX);
+}
+
+function load(dir) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath(dir), "utf8"));
+    const list = Array.isArray(raw) ? raw : raw?.history;
+    return sanitize(list);
+  } catch {
+    return [];
+  }
+}
+
+function save(lines, dir) {
+  const clean = sanitize(lines);
+  try {
+    const file = filePath(dir);
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const tmp = `${file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(clean), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+  } catch {
+    // Histórico é conveniência: falha de disco não pode derrubar a TUI.
+  }
+  return clean;
+}
+
+/** Adiciona uma linha, sem repetir a anterior, e devolve a lista atualizada. */
+function push(line, dir) {
+  const clean = String(line ?? "").replace(/\r/g, "").trim();
+  if (!clean) return load(dir);
+  const lines = load(dir);
+  if (lines[lines.length - 1] === clean) return lines;
+  return save([...lines, clean].slice(-MAX), dir);
+}
+
+module.exports = { MAX, FILE, filePath, load, save, push };

package/src/sessions.js

@@ -69,6 +69,29 @@ function titleFrom(messages, fallback = "") {
   return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX - 1).trimEnd()}…` : text;
 }
 
+/**
+ * Converte a conversa visivel (o que a TUI guarda em `state.messages`) no
+ * contexto que vai para o modelo.
+ *
+ * Sessoes antigas foram salvas sem `context`, mas com a conversa visivel. Sem
+ * essa reconstrucao, retomar a conversa mandava so a mensagem nova ao provedor
+ * e a IA "esquecia" tudo o que ja tinha sido dito.
+ */
+function contextFromMessages(messages) {
+  const context = [];
+  for (const message of Array.isArray(messages) ? messages : []) {
+    const text = String(message?.text ?? message?.content ?? "").trim();
+    if (!text) continue;
+    if (message.role === "user" || message.role === "assistant") {
+      context.push({ role: message.role, content: text });
+    } else if (message.role === "compaction") {
+      // O resumo e contexto, nao mensagem de chat.
+      context.push({ role: "system", content: text });
+    }
+  }
+  return context;
+}
+
 function save({ id, cwd, model, theme, allowAll, messages, context, startedAt, title }) {
   if (!id) return null;
   ensureDir();
@@ -166,6 +189,7 @@ module.exports = {
   titleFrom,
   normalizeId,
   dayMonth,
+  contextFromMessages,
   save,
   load,
   list,

package/src/tui.js

@@ -25,8 +25,10 @@ const { diffBlocks } = require("./diff");
 const { toolMeta, parseCommandOutput } = require("./tools");
 const { McpHub } = require("./mcp");
 const sessions = require("./sessions");
+const promptHistory = require("./prompt-history");
 const wallpaper = require("./wallpaper");
 const { listProviders } = require("./providers");
+const { MAX_IMAGES, loadImage, humanSize } = require("./images");
 
 const ANSI = /\x1b\[[0-9;]*m/g;
 const stripAnsi = (value) => String(value).replace(ANSI, "");
@@ -681,6 +683,10 @@ function initialState() {
   return {
     input: "",
     cursor: 0,
+    // Anexos de imagem do proximo turno (maximo MAX_IMAGES). Sao consumidos
+    // por submit() e nao sobrevivem a ele.
+    images: [],
+    imageError: null,
     history: [],
     historyIndex: -1,
     messages: [],
@@ -1332,22 +1338,6 @@ function sidebarLines(state, width) {
   lines.push(chalk.dim(`${formatTokens(tokens)} tokens · ${messages} msg${messages === 1 ? "" : "s"}`));
   lines.push(chalk.dim(state.balance == null ? "saldo --" : `R$ ${(state.balance / 1_000_000).toFixed(2)}`));
 
-  // Saldo dos provedores externos (unlid etc.): so aparece quando o backend
-  // consegue ler. Moeda vem do provedor; "sem consulta" quando falha.
-  if (state.balanceLoading) lines.push(chalk.dim("atualizando…"));
-  for (const item of state.providerBalances || []) {
-    const label = truncate(item.label || item.id || "provider", Math.max(6, width - 12));
-    if (item.ok && item.balance != null) {
-      const money =
-        item.currency === "BRL"
-          ? `R$ ${Number(item.balance).toFixed(2)}`
-          : `${Number(item.balance).toFixed(2)} ${item.currency || "USD"}`;
-      lines.push(chalk.dim(`${label} `) + chalk.cyan(money));
-    } else {
-      lines.push(chalk.dim(`${label} `) + chalk.dim("--"));
-    }
-  }
-
   lines.push("");
   lines.push(border(state, "MCP"));
   if (state.mcp.loading) {
@@ -1436,30 +1426,87 @@ function modelLine(state, width) {
   );
 }
 
+/**
+ * Preview dos anexos dentro da caixa de input: a imagem pixelada (blocos com
+ * cor real) e, a direita de cada uma, o rotulo clicavel "✕" que a remove.
+ * O preview e montado na ordem inversa de proposito — a TUI desenha a caixa
+ * de baixo para cima ao posicionar o cursor, entao o texto fica por ultimo.
+ */
+function imagePreviewLines(state, width) {
+  const items = state.images || [];
+  state.imageHit = {};
+  if (!items.length) return [];
+
+  const inner = Math.max(10, width - 2);
+  const lines = [];
+
+  items.forEach((image, index) => {
+    const preview = image.preview || [];
+    const label = `${index + 1}. ${truncate(image.name, Math.max(8, inner - 22))} ${chalk.dim(
+      `${image.width}×${image.height} · ${humanSize(image.bytes)}`
+    )}`;
+    const remove = chalk.red.bold("✕");
+    // A linha do rotulo e a ultima coluna util (onde cai o "✕"), para o
+    // clique do mouse acertar o alvo. A TUI pinta 1 espaco de borda a
+    // esquerda, entao a coluna do ✕ (1-based) e a posicao dentro de `inner`.
+    const labelLine = padRight(" " + label, inner - 2) + " " + remove + " ";
+    // 1-based dentro da coluna total: 1 (borda "│") + 1 (espaco) + label + 1.
+    const removeCol = 1 + 1 + visible(label) + 1;
+
+    lines.push(paintPanel(state.theme, padRight(labelLine, inner)));
+    for (const line of preview) {
+      lines.push(paintPanel(state.theme, padRight(" " + line, inner)));
+    }
+
+    state.imageHit[index] = { row: lines.length - 1 - preview.length, col: removeCol };
+  });
+
+  return lines;
+}
+
+/**
+ * Caixa de entrada: borda superior, previews de imagem anexadas (com o "✕"
+ * de remover), a linha de digitacao com cursor e a borda inferior. Devolve as
+ * linhas prontas, a linha/coluna do cursor dentro do bloco e a linha do
+ * rodape (avisos, ex.: modelo sem visao).
+ */
 function inputBlock(state, width, { hero = false, tight = false } = {}) {
-  const available = width - 4;
-  const start =
-    state.input.length > available
-      ? clamp(state.cursor - (available - 2), 0, Math.max(0, state.input.length - available))
-      : 0;
-  const shown = state.input.slice(start, start + available);
-
-  const prompt = chalk.cyan("▌ ");
-  // A caixa fica sempre limpa: o "trabalhando" ja aparece na conversa, acima.
-  const body = state.input ? prompt + shown : prompt;
-
-  const lines = [
-    rule(state, width),
-    paintPanel(state.theme, padRight(body, width)),
-    rule(state, width),
-  ];
+  const inner = Math.max(10, width - 2);
+  const edge = (text) => border(state, text);
+  const row = (content) => edge("│") + paintPanel(state.theme, padRight(content, inner)) + edge("│");
+  const lines = [];
+
+  lines.push(edge("┌" + "─".repeat(inner) + "┐"));
+
+  const previews = hero ? [] : imagePreviewLines(state, inner);
+  for (const preview of previews) lines.push(preview);
+
+  const prompt = hero ? "  " : "› ";
+  const room = Math.max(4, inner - visible(prompt) - 1);
+  // Janela de rolagem horizontal: mantem o cursor visivel em linhas longas.
+  let offset = 0;
+  if (state.cursor > room) offset = state.cursor - room;
+  const shown = state.input.slice(offset, offset + room);
+  const beforeCursor = state.input.slice(offset, state.cursor);
+  // A coluna e absoluta na linha montada pelo frame: 1 espaco de borda +
+  // 1 borda "│" + 1 espaco do row + prompt + o que ja foi digitado.
+  const cursorColInRow = 4 + visible(prompt) + visible(beforeCursor);
+
+  const typed = state.input.length ? shown : chalk.dim("Escreva algo ou /comando");
+  const inputRow = lines.length;
+  lines.push(row(" " + prompt + typed));
+
+  lines.push(edge("└" + "─".repeat(inner) + "┘"));
+
+  const footer = state.imageError
+    ? chalk.red(truncate(`⚠ ${state.imageError}`, width))
+    : null;
 
   return {
     lines,
-    cursorRow: 1,
-    cursorCol: 4 + (state.cursor - start),
-    // O modelo fica fora da caixa de texto, logo abaixo dela.
-    footer: tight ? null : modelLine(state, width),
+    footer,
+    cursorRow: inputRow,
+    cursorCol: cursorColInRow,
   };
 }
 
@@ -1747,6 +1794,8 @@ function buildFrame(state, cols, rows, commands = {}) {
     ...menu,
     ...input.lines,
     ...(input.footer ? [input.footer] : []),
+    // Modelo + versao logo abaixo da caixa (some so em terminal baixo).
+    ...(bare ? [] : [modelLine(state, inner)]),
     ...status,
     ...hints,
   ];
@@ -1794,10 +1843,16 @@ function buildFrame(state, cols, rows, commands = {}) {
     });
   }
 
-  const inputRow = head.length + bodyHeight + queue.length + menu.length + input.cursorRow;
+  const inputTop = head.length + bodyHeight + queue.length + menu.length;
+  const inputRow = inputTop + input.cursorRow;
   const cursorRow = overlay ? 0 : clamp(inputRow + 1, 1, rows);
   const cursorCol = overlay ? 0 : clamp(input.cursorCol, 1, cols);
 
+  // Guarda a linha (0-based) do topo do bloco de entrada para o clique do
+  // mouse acertar o "✕" de cada preview (imageHit usa linhas relativas).
+  state.inputTop = inputTop;
+  state.inputInner = inner;
+
   return {
     lines,
     cursorRow,
@@ -1821,6 +1876,10 @@ async function runTUI({
   const stdin = process.stdin;
   const stdout = process.stdout;
   const state = initialState();
+  // Retoma também o histórico de linhas digitadas (↑/↓). Sem isso cada boot
+  // começava com a lista vazia, mesmo com conversas salvas no disco.
+  state.history = promptHistory.load();
+  state.historyIndex = state.history.length;
 
   // resume: "pick" abre o seletor de conversas, "last" pega a mais recente e
   // qualquer outro valor e o codigo do chat que o usuario fechou no Ctrl+C.
@@ -1839,7 +1898,12 @@ async function runTUI({
         state.sessionId = saved.id;
         state.sessionStartedAt = saved.startedAt;
         state.messages = Array.isArray(saved.messages) ? saved.messages : [];
-        state.context = Array.isArray(saved.context) ? saved.context : [];
+        // Sessao antiga pode nao ter `context`: reconstroi da conversa visivel
+        // para a IA nao esquecer tudo ao retomar.
+        state.context =
+          Array.isArray(saved.context) && saved.context.length
+            ? saved.context
+            : sessions.contextFromMessages(state.messages);
         if (saved.model) state.model = saved.model;
         if (saved.theme) state.theme = saved.theme;
         state.autoApprove = forcedAllow || Boolean(saved.allowAll);
@@ -2143,7 +2207,10 @@ async function runTUI({
     state.sessionId = saved.id;
     state.sessionStartedAt = saved.startedAt;
     state.messages = Array.isArray(saved.messages) ? saved.messages : [];
-    state.context = Array.isArray(saved.context) ? saved.context : [];
+    state.context =
+      Array.isArray(saved.context) && saved.context.length
+        ? saved.context
+        : sessions.contextFromMessages(state.messages);
     if (saved.model) state.model = saved.model;
     if (saved.theme) state.theme = saved.theme;
     state.autoApprove = forcedAllow || Boolean(saved.allowAll);
@@ -2225,6 +2292,35 @@ async function runTUI({
     }
   }
 
+  // Anexa imagem(ns) ao proximo turno. Aceita um ou mais caminhos separados
+  // por espaco. Respeita MAX_IMAGES e grava o ultimo erro em state.imageError.
+  async function attachImages(argument) {
+    const files = String(argument || "")
+      .split(/\s+/)
+      .map((part) => part.trim())
+      .filter(Boolean);
+    if (!files.length) return render();
+
+    const items = state.images || (state.images = []);
+    let lastError = null;
+
+    for (const file of files) {
+      if (items.length >= MAX_IMAGES) {
+        lastError = `limite de ${MAX_IMAGES} imagens por mensagem`;
+        break;
+      }
+      const result = loadImage(file.replace(/^~(?=\/)/, os.homedir()));
+      if (!result || !result.ok) {
+        lastError = `${path.basename(file)}: ${result?.error || "falha ao carregar"}`;
+        continue;
+      }
+      items.push(result.attachment);
+    }
+
+    state.imageError = lastError;
+    return render();
+  }
+
   async function runCommand(line) {
     const parts = line.trim().split(/\s+/);
     const name = parts[0];
@@ -2232,6 +2328,31 @@ async function runTUI({
 
     // /models e /model sem argumento abrem o mesmo seletor navegavel.
     if ((name === "/model" || name === "/models") && !parts[1]) return openModelPicker();
+
+    // /image <arquivo> anexa uma imagem ao proximo turno (ate MAX_IMAGES).
+    // /image (sem argumento) lista o que esta anexado; /image clear limpa tudo.
+    if (name === "/image" || name === "/images" || name === "/anexar") {
+      const argument = parts.slice(1).join(" ").trim();
+      if (!argument) {
+        const items = state.images || [];
+        state.modal = {
+          title: "Imagens",
+          text: items.length
+            ? `${items
+                .map((image, index) => `${index + 1}. ${image.name}  (${image.width}×${image.height} · ${humanSize(image.bytes)})`)
+                .join("\n")}\n\nUse /image clear para remover todas. Clique no ✕ do preview para tirar uma.`
+            : "Nenhuma imagem anexada.\n\nUse /image <arquivo> para anexar (PNG ou JPG, ate " +
+              `${MAX_IMAGES} por vez). Exemplo: /image ~/Imagens/grafico.png`,
+        };
+        return render();
+      }
+      if (/^(clear|limpar|off|none|limpa)$/i.test(argument)) {
+        state.images = [];
+        state.imageError = null;
+        return render();
+      }
+      return attachImages(argument);
+    }
     if (name === "/theme") return openThemePicker();
     if (name === "/background" || name === "/bg") {
       const value = parts.slice(1).join(" ");
@@ -2425,7 +2546,7 @@ async function runTUI({
   function submit() {
     const line = state.input.trim();
     if (!line) return;
-    state.history.push(line);
+    state.history = promptHistory.push(line);
     state.historyIndex = state.history.length;
     state.input = "";
     state.cursor = 0;
@@ -2467,7 +2588,27 @@ async function runTUI({
     state.abort = controller;
     state.escArmed = false;
     startMessageText(line);
-    state.context.push({ role: "user", content: line });
+    // Imagens anexadas viram partes multimodais no content desta mensagem.
+    // O anexo e consumido no turno: some da lista assim que entra no contexto.
+    const attached = state.images || [];
+    // Guarda o tamanho do contexto ANTES deste turno: se o provedor recusar as
+    // imagens (vision_not_supported), desfazemos o push e devolvemos os anexos
+    // para o usuario reaproveitar com outro modelo, sem reenviar tudo a mao.
+    const contextBefore = state.context.length;
+    if (attached.length) {
+      state.context.push({
+        role: "user",
+        content: [
+          { type: "text", text: line },
+          ...attached.map((image) => ({ type: "image_url", image_url: { url: image.dataUrl } })),
+        ],
+      });
+      startMessageText(`📎 ${attached.length} imagem(ns) anexada(s)`);
+      state.images = [];
+      state.imageError = null;
+    } else {
+      state.context.push({ role: "user", content: line });
+    }
     state.busy = true;
     state.streaming = { text: "", reasoning: "", thinkingStartedAt: 0 };
     state.scroll = 0;
@@ -2602,6 +2743,23 @@ async function runTUI({
       if (result.messages) state.context = trimHistory(result.messages);
       // Reconectou de verdade: limpa o alerta e os erros de rede pendentes.
       clearRetry();
+    } else if (result.code === "vision_not_supported") {
+      // O modelo escolhido não aceita imagens: nada de erro genérico nem de
+      // retry automático (reenviar a mesma imagem falharia de novo). Avisa de
+      // forma clara e sugere trocar para um modelo com visão.
+      // Desfaz o turno no contexto e devolve os anexos para reuso.
+      if (attached.length && state.context.length > contextBefore) {
+        state.context.length = contextBefore;
+        state.images = attached;
+      }
+      state.messages.push({
+        role: "system",
+        text:
+          result.error ||
+          "Este modelo não aceita imagens. Escolha um modelo com visão (ex.: `kafox model`) e envie de novo — o anexo foi mantido.",
+        error: true,
+        connectionError: false,
+      });
     } else {
       // Erro de rede/servidor entra marcado como transitório: some sozinho
       // quando a próxima resposta chegar. Erros de verdade (saldo, chave)
@@ -2736,6 +2894,22 @@ async function runTUI({
     const cols = Math.max(30, stdout.columns || 80);
     const rows = Math.max(14, stdout.rows || 24);
     const overlay = buildOverlay(state, cols, rows);
+
+    // "✕" dos previews: alvo clicavel mesmo sem overlay aberto. As coords do
+    // mouse sao 1-based; imageHit guarda linha relativa + coluna 1-based.
+    if (!overlay && state.imageHit && state.inputTop != null) {
+      const rowAt = y - 1;
+      for (const [key, hit] of Object.entries(state.imageHit)) {
+        if (state.inputTop + hit.row !== rowAt) continue;
+        const col = x - 1;
+        if (col < hit.col - 1 || col > hit.col + 1) continue;
+        const index = Number(key);
+        state.images.splice(index, 1);
+        state.imageError = null;
+        return render();
+      }
+    }
+
     if (!overlay || !overlay.hit) return;
 
     const { first, count, left, width, kind } = overlay.hit;