kafox-cli 0.2.3 → 0.6.0

package/src/theme.js

@@ -2,7 +2,316 @@ const inquirer = require("inquirer");
 const chalk = require("chalk");
 const storage = require("./storage");
 
-const THEMES = ["default", "dark", "light", "brutalist", "neon", "paper"];
+// Ordem da lista do /theme: primeiro os que seguem o terminal, depois os
+// escuros, os claros e por fim os de contraste forte.
+const THEMES = [
+  "default",
+  "dark",
+  "light",
+  "brutalist",
+  "neon",
+  "paper",
+  "dracula",
+  "nord",
+  "gruvbox",
+  "monokai",
+  "tokyo-night",
+  "catppuccin",
+  "solarized",
+  "midnight",
+  "ocean",
+  "forest",
+  "sunset",
+  "plum",
+  "synthwave",
+  "cyberpunk",
+  "amoled",
+  "matrix",
+  "terminal",
+  "solarized-light",
+  "rose",
+  "mint",
+  "sepia",
+  "ice",
+  "high-contrast",
+];
+
+// Cores por tema: `accent` destaca negrito/titulos, `bg`/`fg` pintam a tela
+// inteira (o preview do /theme aparece ja com o fundo do tema escolhido).
+// `panel` pinta a caixa de input; `accent` destaca negrito/titulos; `border`
+// desenha reguas e molduras do modal.
+const THEME_DEFS = {
+  default: { accent: "yellow", bg: null, fg: null, panel: null, border: "#4b5563", mascot: "white" },
+  dark: {
+    accent: "yellowBright",
+    bg: "#0e1116",
+    fg: "#e8e8e8",
+    panel: "#171c24",
+    border: "#3d4653",
+    mascot: "white",
+  },
+  light: {
+    accent: "#8a5a00",
+    bg: "#f4f4f2",
+    fg: "#1b1b1b",
+    panel: "#e6e6e2",
+    border: "#b8b8b2",
+    mascot: "black",
+  },
+  brutalist: {
+    accent: "#111111",
+    bg: "#f5e663",
+    fg: "#111111",
+    panel: "#efe04d",
+    border: "#111111",
+    mascot: "black",
+  },
+  neon: {
+    accent: "magentaBright",
+    bg: "#150022",
+    fg: "#f2e9ff",
+    panel: "#24003a",
+    border: "#7a3bff",
+    mascot: "magenta",
+  },
+  paper: {
+    accent: "#7a4b00",
+    bg: "#f4ecd8",
+    fg: "#3a2f1f",
+    panel: "#eadfc4",
+    border: "#b9a67e",
+    mascot: "black",
+  },
+
+  /* ---------------------------------------------------------- escuros */
+  dracula: {
+    accent: "#bd93f9",
+    bg: "#282a36",
+    fg: "#f8f8f2",
+    panel: "#343746",
+    border: "#6272a4",
+    mascot: "magenta",
+  },
+  nord: {
+    accent: "#88c0d0",
+    bg: "#2e3440",
+    fg: "#eceff4",
+    panel: "#3b4252",
+    border: "#4c566a",
+    mascot: "cyan",
+  },
+  gruvbox: {
+    accent: "#fabd2f",
+    bg: "#282828",
+    fg: "#ebdbb2",
+    panel: "#3c3836",
+    border: "#665c54",
+    mascot: "yellow",
+  },
+  monokai: {
+    accent: "#f92672",
+    bg: "#272822",
+    fg: "#f8f8f2",
+    panel: "#3b3a34",
+    border: "#75715e",
+    mascot: "magenta",
+  },
+  "tokyo-night": {
+    accent: "#7aa2f7",
+    bg: "#1a1b26",
+    fg: "#c0caf5",
+    panel: "#24283b",
+    border: "#414868",
+    mascot: "blue",
+  },
+  catppuccin: {
+    accent: "#cba6f7",
+    bg: "#1e1e2e",
+    fg: "#cdd6f4",
+    panel: "#313244",
+    border: "#585b70",
+    mascot: "magenta",
+  },
+  solarized: {
+    accent: "#b58900",
+    bg: "#002b36",
+    fg: "#93a1a1",
+    panel: "#073642",
+    border: "#586e75",
+    mascot: "yellow",
+  },
+  midnight: {
+    accent: "#38bdf8",
+    bg: "#0f172a",
+    fg: "#e2e8f0",
+    panel: "#1e293b",
+    border: "#334155",
+    mascot: "cyan",
+  },
+  ocean: {
+    accent: "#4cc9f0",
+    bg: "#0b2545",
+    fg: "#d6e4f0",
+    panel: "#123a6b",
+    border: "#2a628f",
+    mascot: "cyan",
+  },
+  forest: {
+    accent: "#7ee787",
+    bg: "#10231a",
+    fg: "#d4e8d4",
+    panel: "#17352a",
+    border: "#2f5d43",
+    mascot: "green",
+  },
+  sunset: {
+    accent: "#ff8c42",
+    bg: "#2b1b17",
+    fg: "#ffd9b3",
+    panel: "#3a2620",
+    border: "#7a4a35",
+    mascot: "yellow",
+  },
+  plum: {
+    accent: "#d8b4fe",
+    bg: "#2a1a33",
+    fg: "#f0e6f6",
+    panel: "#3a2447",
+    border: "#6b4a7d",
+    mascot: "magenta",
+  },
+  synthwave: {
+    accent: "#ff7edb",
+    bg: "#241b2f",
+    fg: "#ffe6ff",
+    panel: "#2f2138",
+    border: "#7b2fbe",
+    mascot: "magenta",
+  },
+  cyberpunk: {
+    accent: "#ff2a6d",
+    bg: "#0d0221",
+    fg: "#f2f2f2",
+    panel: "#1a0b33",
+    border: "#05d9e8",
+    mascot: "magenta",
+  },
+  amoled: {
+    accent: "#00d7ff",
+    bg: "#000000",
+    fg: "#e6e6e6",
+    panel: "#0a0a0a",
+    border: "#2b2b2b",
+    mascot: "cyan",
+  },
+  matrix: {
+    accent: "#00ff41",
+    bg: "#000000",
+    fg: "#33ff33",
+    panel: "#081c08",
+    border: "#00a300",
+    mascot: "green",
+  },
+  terminal: {
+    accent: "#00ff00",
+    bg: "#000000",
+    fg: "#c0c0c0",
+    panel: "#0c0c0c",
+    border: "#303030",
+    mascot: "green",
+  },
+
+  /* ----------------------------------------------------------- claros */
+  "solarized-light": {
+    accent: "#cb4b16",
+    bg: "#fdf6e3",
+    fg: "#586e75",
+    panel: "#eee8d5",
+    border: "#93a1a1",
+    mascot: "black",
+  },
+  rose: {
+    accent: "#c9184a",
+    bg: "#fff0f3",
+    fg: "#4a1220",
+    panel: "#ffe0e7",
+    border: "#e29aa9",
+    mascot: "black",
+  },
+  mint: {
+    accent: "#0f766e",
+    bg: "#eefbf4",
+    fg: "#10392c",
+    panel: "#d9f4e6",
+    border: "#8fcfb6",
+    mascot: "black",
+  },
+  sepia: {
+    accent: "#8a6d3b",
+    bg: "#e8ddc4",
+    fg: "#4a3b23",
+    panel: "#ddd0b1",
+    border: "#b3a17b",
+    mascot: "black",
+  },
+  ice: {
+    accent: "#1d4ed8",
+    bg: "#f2f7ff",
+    fg: "#17293f",
+    panel: "#e2ecff",
+    border: "#9db8e0",
+    mascot: "black",
+  },
+  "high-contrast": {
+    accent: "#ffff00",
+    bg: "#000000",
+    fg: "#ffffff",
+    panel: "#111111",
+    border: "#ffffff",
+    mascot: "white",
+  },
+};
+
+function themeColors(theme) {
+  return THEME_DEFS[theme] || THEME_DEFS.default;
+}
+
+/** Pinta uma linha inteira com o fundo/texto do tema (chalk cuida do aninhamento). */
+function paintLine(theme, text) {
+  const { bg, fg } = themeColors(theme);
+  let out = String(text);
+  if (fg) out = chalk.hex(fg)(out);
+  if (bg) out = chalk.bgHex(bg)(out);
+  return out;
+}
+
+function mascotColor(theme) {
+  const color = themeColors(theme).mascot;
+  if (typeof chalk[color] === "function") return chalk[color];
+  if (typeof color === "string" && color.startsWith("#")) return chalk.hex(color);
+  return chalk.white;
+}
+
+/** Cor das reguas e molduras (dim quando o tema nao define uma). */
+function borderColor(theme) {
+  const { border } = themeColors(theme);
+  if (!border) return chalk.dim;
+  return chalk.hex(border);
+}
+
+/** Destaca titulos/negrito com a cor de destaque do tema. */
+function accentPainter(theme) {
+  const { accent } = themeColors(theme);
+  if (typeof chalk[accent] === "function") return chalk[accent];
+  return chalk.hex(accent);
+}
+
+/** Pinta o interior da caixa de input (usa o bg do tema quando nao ha panel). */
+function paintPanel(theme, text) {
+  const { bg, panel } = themeColors(theme);
+  const target = panel || bg;
+  return target ? chalk.bgHex(target)(text) : text;
+}
 
 function paint(theme, text) {
   switch (theme) {
@@ -16,8 +325,11 @@ function paint(theme, text) {
       return chalk.black(text);
     case "dark":
       return chalk.cyan(text);
-    default:
+    case "default":
       return chalk.green(text);
+    default:
+      // Qualquer tema novo usa o proprio destaque.
+      return accentPainter(theme)(text);
   }
 }
 
@@ -61,4 +373,16 @@ async function setContentBackground(url) {
   );
 }
 
-module.exports = { runTheme, setContentBackground, THEMES, paint };
+module.exports = {
+  runTheme,
+  setContentBackground,
+  THEMES,
+  THEME_DEFS,
+  themeColors,
+  paintLine,
+  paintPanel,
+  mascotColor,
+  borderColor,
+  accentPainter,
+  paint,
+};

package/src/tools.js

@@ -0,0 +1,359 @@
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+// Limites para nao estourar o contexto nem travar a TUI.
+const MAX_READ_CHARS = 40_000;
+const MAX_READ_LINES = 400;
+const MAX_WRITE_CHARS = 120_000;
+const MAX_LIST_ENTRIES = 300;
+const MAX_OUTPUT_CHARS = 12_000;
+const COMMAND_TIMEOUT_MS = 60_000;
+
+const TOOL_SPECS = [
+  {
+    type: "function",
+    function: {
+      name: "read_file",
+      description:
+        "Le um arquivo de texto do diretorio de trabalho. Use offset/limit para trechos grandes.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Caminho relativo ao diretorio de trabalho" },
+          offset: { type: "integer", description: "Linha inicial (1-based)" },
+          limit: { type: "integer", description: "Quantidade de linhas (max 400)" },
+        },
+        required: ["path"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "list_dir",
+      description: "Lista arquivos e pastas de um diretorio do projeto.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Diretorio relativo (padrao: raiz do projeto)" },
+        },
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "write_file",
+      description:
+        "Cria um arquivo novo ou reescreve um arquivo inteiro no diretorio de trabalho. Cria as pastas necessarias.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Caminho relativo ao diretorio de trabalho" },
+          content: { type: "string", description: "Conteudo completo do arquivo" },
+        },
+        required: ["path", "content"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "edit_file",
+      description:
+        "Troca um trecho exato de um arquivo existente por outro. Prefira esta ferramenta a reescrever o arquivo inteiro.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Caminho relativo ao diretorio de trabalho" },
+          old_string: { type: "string", description: "Trecho atual, exatamente como esta no arquivo" },
+          new_string: { type: "string", description: "Trecho que substitui o anterior" },
+          replace_all: {
+            type: "boolean",
+            description: "Troca todas as ocorrencias (padrao: so quando for unica)",
+          },
+        },
+        required: ["path", "old_string", "new_string"],
+      },
+    },
+  },
+  {
+    type: "function",
+    function: {
+      name: "run_command",
+      description:
+        "Executa um comando de shell no diretorio de trabalho e devolve stdout, stderr e o codigo de saida.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Comando a executar" },
+          timeout_ms: { type: "integer", description: "Timeout em ms (padrao 60000, max 120000)" },
+        },
+        required: ["command"],
+      },
+    },
+  },
+];
+
+const LOCAL_TOOL_NAMES = new Set(TOOL_SPECS.map((tool) => tool.function.name));
+const TOOL_NAMES = LOCAL_TOOL_NAMES;
+// Ferramentas que mudam o disco ou executam codigo pedem aprovacao.
+const APPROVAL_REQUIRED = new Set(["write_file", "edit_file", "run_command"]);
+
+const TOOL_META = {
+  read_file: { kind: "read", label: "Read" },
+  list_dir: { kind: "list", label: "List" },
+  write_file: { kind: "write", label: "Write" },
+  edit_file: { kind: "edit", label: "Edit" },
+  run_command: { kind: "bash", label: "Bash" },
+};
+
+function toolMeta(name, hub) {
+  if (TOOL_META[name]) return { ...TOOL_META[name], mcp: null };
+  const entry = hub?.describe?.(name);
+  if (entry) return { kind: "mcp", label: "MCP", server: entry.server, tool: entry.tool };
+  return { kind: "tool", label: name || "tool" };
+}
+
+function resolveInside(cwd, target) {
+  const root = path.resolve(cwd);
+  const full = path.resolve(root, target || ".");
+  if (full !== root && !full.startsWith(root + path.sep)) {
+    throw new Error(`caminho fora do diretorio de trabalho: ${target}`);
+  }
+  return full;
+}
+
+function relative(cwd, full) {
+  const rel = path.relative(path.resolve(cwd), full);
+  return rel === "" ? "." : rel;
+}
+
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}\n... (cortado, ${text.length - max} caracteres a mais)`;
+}
+
+function readTextFile(cwd, target) {
+  const full = resolveInside(cwd, target);
+  if (!fs.existsSync(full)) throw new Error(`arquivo nao encontrado: ${target}`);
+  if (fs.statSync(full).isDirectory()) throw new Error(`${target} e um diretorio`);
+  return { full, content: fs.readFileSync(full, "utf8") };
+}
+
+function readFile(cwd, args) {
+  const { full, content: raw } = readTextFile(cwd, args.path);
+
+  const offset = Math.max(1, Number(args.offset) || 1);
+  const limit = Math.min(MAX_READ_LINES, Math.max(1, Number(args.limit) || MAX_READ_LINES));
+  const lines = raw.split("\n");
+  const slice = lines.slice(offset - 1, offset - 1 + limit);
+  const header =
+    offset > 1 || slice.length < lines.length
+      ? `# ${relative(cwd, full)} linhas ${offset}-${offset + slice.length - 1} de ${lines.length}\n`
+      : "";
+  return truncate(header + slice.join("\n"), MAX_READ_CHARS);
+}
+
+function writeFile(cwd, args) {
+  const full = resolveInside(cwd, args.path);
+  const content = String(args.content ?? "");
+  if (content.length > MAX_WRITE_CHARS) {
+    throw new Error(`conteudo grande demais (${content.length} chars, max ${MAX_WRITE_CHARS})`);
+  }
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content, "utf8");
+  return `ok: ${relative(cwd, full)} (${content.length} caracteres escritos)`;
+}
+
+/** Aplica a troca de trecho; separado da escrita para permitir o preview. */
+function applyEdit(cwd, args) {
+  const oldString = String(args.old_string ?? "");
+  const newString = String(args.new_string ?? "");
+  if (!oldString) throw new Error("old_string vazio: diga qual trecho deve sair");
+
+  const { full, content } = readTextFile(cwd, args.path);
+  const occurrences = content.split(oldString).length - 1;
+  if (!occurrences) throw new Error(`trecho nao encontrado em ${args.path}`);
+  if (occurrences > 1 && !args.replace_all) {
+    throw new Error(
+      `o trecho aparece ${occurrences} vezes em ${args.path}: inclua mais contexto ou use replace_all`
+    );
+  }
+
+  const after = args.replace_all
+    ? content.split(oldString).join(newString)
+    : content.replace(oldString, newString);
+  if (after.length > MAX_WRITE_CHARS) {
+    throw new Error(`resultado grande demais (${after.length} chars, max ${MAX_WRITE_CHARS})`);
+  }
+  return { full, before: content, after, occurrences };
+}
+
+function editFile(cwd, args) {
+  const { full, after, occurrences } = applyEdit(cwd, args);
+  fs.writeFileSync(full, after, "utf8");
+  return `ok: ${relative(cwd, full)} editado (${occurrences} trecho${occurrences > 1 ? "s" : ""})`;
+}
+
+function listDir(cwd, args) {
+  const full = resolveInside(cwd, args.path);
+  if (!fs.existsSync(full)) throw new Error(`diretorio nao encontrado: ${args.path || "."}`);
+  const entries = fs.readdirSync(full, { withFileTypes: true });
+  const rows = entries
+    .sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name))
+    .slice(0, MAX_LIST_ENTRIES)
+    .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name));
+  const extra = entries.length > rows.length ? `\n... (+${entries.length - rows.length})` : "";
+  return `${relative(cwd, full)}\n${rows.join("\n")}${extra}`;
+}
+
+function runCommand(cwd, args) {
+  const command = String(args.command || "").trim();
+  if (!command) throw new Error("comando vazio");
+  const timeout = Math.min(120_000, Math.max(1_000, Number(args.timeout_ms) || COMMAND_TIMEOUT_MS));
+
+  const result = spawnSync(command, {
+    shell: true,
+    cwd: path.resolve(cwd),
+    timeout,
+    encoding: "utf8",
+    maxBuffer: 8 * 1024 * 1024,
+    env: { ...process.env, KAFOX_CLI: "1" },
+  });
+
+  const stdout = truncate(result.stdout || "", MAX_OUTPUT_CHARS);
+  const stderr = truncate(result.stderr || "", MAX_OUTPUT_CHARS);
+  const parts = [`exit: ${result.status == null ? "?" : result.status}`];
+  if (result.error?.code === "ETIMEDOUT") parts.push(`timeout: ${timeout}ms`);
+  if (stdout.trim()) parts.push(`stdout:\n${stdout.trimEnd()}`);
+  if (stderr.trim()) parts.push(`stderr:\n${stderr.trimEnd()}`);
+  return parts.join("\n");
+}
+
+async function executeTool(name, args = {}, context = {}) {
+  const cwd = context.cwd || process.cwd();
+  if (!LOCAL_TOOL_NAMES.has(name)) {
+    if (context.mcp?.has?.(name)) return context.mcp.call(name, args);
+    throw new Error(`ferramenta desconhecida: ${name}`);
+  }
+  switch (name) {
+    case "read_file":
+      return readFile(cwd, args);
+    case "write_file":
+      return writeFile(cwd, args);
+    case "edit_file":
+      return editFile(cwd, args);
+    case "list_dir":
+      return listDir(cwd, args);
+    case "run_command":
+      return runCommand(cwd, args);
+    default:
+      throw new Error(`ferramenta desconhecida: ${name}`);
+  }
+}
+
+/**
+ * O que a ferramenta vai mudar no arquivo, sem escrever nada.
+ * Usado no modal de aprovacao e no diff mostrado na conversa.
+ */
+function previewToolChange(name, args = {}, context = {}) {
+  const cwd = context.cwd || process.cwd();
+  if (name === "write_file") {
+    const full = resolveInside(cwd, args.path);
+    const exists = fs.existsSync(full) && !fs.statSync(full).isDirectory();
+    return {
+      kind: exists ? "update" : "create",
+      path: relative(cwd, full),
+      before: exists ? fs.readFileSync(full, "utf8") : null,
+      after: String(args.content ?? ""),
+    };
+  }
+  if (name === "edit_file") {
+    try {
+      const { full, before, after, occurrences } = applyEdit(cwd, args);
+      return { kind: "edit", path: relative(cwd, full), before, after, occurrences };
+    } catch (error) {
+      return {
+        kind: "edit",
+        path: String(args.path || ""),
+        before: null,
+        after: null,
+        error: error.message,
+      };
+    }
+  }
+  if (name === "run_command") {
+    return { kind: "command", command: String(args.command || "") };
+  }
+  return null;
+}
+
+/** Resumo curto da chamada para mostrar na conversa. */
+function describeToolCall(name, args = {}) {
+  if (name === "read_file") return args.path || "(arquivo)";
+  if (name === "write_file") return `${args.path || "(arquivo)"} (${String(args.content || "").length} chars)`;
+  if (name === "edit_file") return `${args.path || "(arquivo)"}`;
+  if (name === "list_dir") return args.path || ".";
+  if (name === "run_command") return args.command || "(comando)";
+  return "";
+}
+
+/**
+ * Separa a saida de run_command no que a TUI precisa mostrar:
+ * codigo de saida, se deu timeout, stdout e stderr.
+ */
+function parseCommandOutput(output) {
+  const result = { exit: null, timedOut: false, stdout: [], stderr: [] };
+  let bucket = null;
+
+  for (const raw of String(output ?? "").split("\n")) {
+    const line = raw.replace(/\s+$/, "");
+    const exit = line.match(/^exit:\s*(.+)$/);
+    if (exit) {
+      result.exit = exit[1].trim() === "?" ? null : Number(exit[1]);
+      continue;
+    }
+    if (/^timeout:\s*\d+ms$/.test(line)) {
+      result.timedOut = true;
+      continue;
+    }
+    if (line === "stdout:") {
+      bucket = "stdout";
+      continue;
+    }
+    if (line === "stderr:") {
+      bucket = "stderr";
+      continue;
+    }
+    if (bucket) result[bucket].push(line);
+  }
+
+  return result;
+}
+
+/** Uma linha de resumo do resultado (primeira linha util da saida). */
+function summarizeOutput(output) {
+  const first = String(output || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)[0];
+  return first ? first.slice(0, 200) : "(sem saida)";
+}
+
+module.exports = {
+  TOOL_SPECS,
+  TOOL_NAMES,
+  LOCAL_TOOL_NAMES,
+  APPROVAL_REQUIRED,
+  TOOL_META,
+  toolMeta,
+  executeTool,
+  previewToolChange,
+  describeToolCall,
+  summarizeOutput,
+  parseCommandOutput,
+  resolveInside,
+  MAX_WRITE_CHARS,
+};