kafox-cli 0.10.1 → 0.10.3

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,