kafox-cli 0.3.0 → 0.7.0

package/src/sessions.js

@@ -0,0 +1,138 @@
+/**
+ * Historico de conversas do CLI.
+ *
+ * Cada sessao vira um arquivo em ~/.kafox/chats/<codigo>.json e o codigo curto
+ * e o que aparece no `kafox resume <codigo>` (e no `kafox history`).
+ */
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const storage = require("./storage");
+
+// Poda: com muitos arquivos a pasta vira lixo e o `history` precisa listar rapido.
+const MAX_SESSIONS = 60;
+const TITLE_MAX = 60;
+
+const FALLBACK_DIR = process.env.KAFOX_HOME
+  ? path.resolve(process.env.KAFOX_HOME)
+  : path.join(os.homedir(), ".kafox");
+
+// storage.DIR vem do modulo real; em teste ele pode ser stub, entao nunca
+// confiar cegamente (path.join(undefined) estoura).
+function baseDir() {
+  return storage.DIR || FALLBACK_DIR;
+}
+
+function chatsDir() {
+  return path.join(baseDir(), "chats");
+}
+
+function ensureDir() {
+  fs.mkdirSync(chatsDir(), { recursive: true, mode: 0o700 });
+}
+
+function newId() {
+  return crypto.randomBytes(4).toString("hex");
+}
+
+function fileFor(id) {
+  return path.join(chatsDir(), `${id}.json`);
+}
+
+/** Titulo curto: primeira mensagem do usuario, em uma linha. */
+function titleFrom(messages, fallback = "") {
+  const first = (messages || []).find(
+    (message) => message?.role === "user" && String(message.text || "").trim()
+  );
+  const text = String(first?.text || fallback || "")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!text) return "conversa sem titulo";
+  return text.length > TITLE_MAX ? `${text.slice(0, TITLE_MAX - 1).trimEnd()}…` : text;
+}
+
+function save({ id, cwd, model, theme, messages, context, startedAt, title }) {
+  if (!id) return null;
+  ensureDir();
+  const now = new Date().toISOString();
+  const list = Array.isArray(messages) ? messages : [];
+  const data = {
+    id,
+    title: title || titleFrom(list),
+    cwd: cwd || process.cwd(),
+    model: model || null,
+    theme: theme || null,
+    startedAt: startedAt || now,
+    updatedAt: now,
+    messages: list,
+    context: Array.isArray(context) ? context : [],
+  };
+  const tmp = `${fileFor(id)}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(data), { mode: 0o600 });
+  fs.renameSync(tmp, fileFor(id));
+  prune();
+  return data;
+}
+
+function load(id) {
+  if (!id) return null;
+  try {
+    const data = JSON.parse(fs.readFileSync(fileFor(id), "utf8"));
+    if (!data || typeof data !== "object") return null;
+    // Arquivo antigo pode nao ter titulo: deriva das mensagens.
+    if (!data.title) data.title = titleFrom(data.messages);
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+function list() {
+  let names = [];
+  try {
+    names = fs.readdirSync(chatsDir()).filter((name) => name.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const chats = [];
+  for (const name of names) {
+    const id = name.replace(/\.json$/, "");
+    const data = load(id);
+    if (!data) continue;
+    chats.push({
+      id,
+      title: data.title || titleFrom(data.messages),
+      cwd: data.cwd,
+      model: data.model,
+      updatedAt: data.updatedAt,
+      messages: (data.messages || []).length,
+    });
+  }
+  return chats.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+}
+
+function latest() {
+  return list()[0] || null;
+}
+
+function prune() {
+  for (const chat of list().slice(MAX_SESSIONS)) {
+    try {
+      fs.unlinkSync(fileFor(chat.id));
+    } catch {}
+  }
+}
+
+module.exports = {
+  MAX_SESSIONS,
+  TITLE_MAX,
+  chatsDir,
+  newId,
+  titleFrom,
+  save,
+  load,
+  list,
+  latest,
+  prune,
+};

package/src/storage.js

@@ -4,7 +4,8 @@ const path = require("path");
 const os = require("os");
 
 const HOME = os.homedir();
-const DIR = path.join(HOME, ".kafox");
+// KAFOX_HOME aponta a pasta de configuracao direto (testes e uso portatil).
+const DIR = process.env.KAFOX_HOME ? path.resolve(process.env.KAFOX_HOME) : path.join(HOME, ".kafox");
 const TOKEN_FILE = path.join(DIR, "token.json");
 const CONFIG_FILE = path.join(DIR, "config.json");
 

package/src/subagents.js

@@ -0,0 +1,156 @@
+/**
+ * Subagentes: um agente dentro do agente.
+ *
+ * O modelo chama `spawn_subagent` com um objetivo; cada tarefa roda em contexto
+ * proprio (nao polui a conversa principal) e devolve apenas o resultado final.
+ * Várias tarefas rodam em paralelo, o que serve para investigar pontos
+ * diferentes do projeto ao mesmo tempo (auditoria, testes, levantamento).
+ */
+const SUBAGENT_TOOL_NAME = "spawn_subagent";
+const MAX_TASKS = 3;
+const MAX_DEPTH = 1;
+// Subagente tambem nao tem teto por padrao: roda ate entregar o objetivo.
+const DEFAULT_MAX_STEPS = Infinity;
+const READ_ONLY_TOOLS = ["read_file", "list_dir"];
+const ALL_LOCAL_TOOLS = ["read_file", "list_dir", "write_file", "edit_file", "run_command"];
+
+const SUBAGENT_TOOL = {
+  type: "function",
+  function: {
+    name: SUBAGENT_TOOL_NAME,
+    description:
+      "Lanca um ou mais subagentes com objetivo proprio. Cada subagente roda em contexto separado, usa as ferramentas liberadas (padrao: read_file e list_dir) e devolve so o resultado final. Use para dividir trabalho, investigar varios pontos em paralelo (auditoria, testes, busca de arquivos) ou tarefas longas que nao precisam sujar esta conversa.",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: {
+          type: "array",
+          description: `Lista de tarefas (1 a ${MAX_TASKS}). Independentes rodam em paralelo.`,
+          items: {
+            type: "object",
+            properties: {
+              objective: {
+                type: "string",
+                description: "O que o subagente deve entregar, com o criterio de pronto",
+              },
+              context: {
+                type: "string",
+                description: "Contexto extra: arquivos, caminhos, comandos, restricoes",
+              },
+              tools: {
+                type: "array",
+                items: { type: "string" },
+                description:
+                  "Ferramentas liberadas para esta tarefa (read_file, list_dir, write_file, edit_file, run_command). Padrao: read_file e list_dir.",
+              },
+              max_steps: {
+                type: "integer",
+                description: "Limite de passos (opcional; sem ele o subagente roda ate terminar)",
+              },
+            },
+            required: ["objective"],
+          },
+        },
+        objective: {
+          type: "string",
+          description: "Atalho para uma unica tarefa (equivalente a tasks: [{objective}])",
+        },
+        context: { type: "string", description: "Contexto extra para a tarefa unica" },
+        model: { type: "string", description: "Modelo dos subagentes (padrao: o da sessao)" },
+      },
+    },
+  },
+};
+
+function normalizeTasks(args = {}) {
+  const list = [];
+  if (Array.isArray(args.tasks)) {
+    for (const item of args.tasks) {
+      if (!item) continue;
+      if (typeof item === "string") list.push({ objective: item });
+      else if (item.objective) list.push(item);
+    }
+  } else if (args.objective) {
+    list.push({ objective: args.objective, context: args.context, tools: args.tools });
+  }
+  return list.slice(0, MAX_TASKS).map((task) => ({
+    objective: String(task.objective).trim(),
+    context: task.context ? String(task.context) : "",
+    tools: allowedTools(task.tools),
+    maxSteps: Number(task.max_steps || task.maxSteps) > 0 ? Number(task.max_steps || task.maxSteps) : Infinity,
+  }));
+}
+
+function allowedTools(requested) {
+  if (!Array.isArray(requested) || !requested.length) return [...READ_ONLY_TOOLS];
+  const chosen = requested
+    .map((name) => String(name).trim())
+    .filter((name) => ALL_LOCAL_TOOLS.includes(name));
+  return chosen.length ? [...new Set(chosen)] : [...READ_ONLY_TOOLS];
+}
+
+function subagentPrompt({ objective, context, cwd, depth }) {
+  return [
+    "Voce e um subagente do kafox CLI, rodando em contexto separado do agente principal.",
+    `Diretorio de trabalho: ${cwd}`,
+    `Objetivo: ${objective}`,
+    context ? `Contexto: ${context}` : "",
+    depth >= MAX_DEPTH ? "Nao lance outros subagentes." : "",
+    "Trabalhe so no objetivo recebido, use as ferramentas disponiveis e pare quando tiver a resposta.",
+    "Devolva um relatorio curto e direto em Markdown: o que encontrou, evidencias (arquivo:linha, saida de comando) e o que ficou em duvida.",
+    "Nao invente nada: se nao conseguiu verificar, diga isso explicitamente.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function describeSubagentCall(args = {}) {
+  const tasks = normalizeTasks(args);
+  if (!tasks.length) return "(sem objetivo)";
+  if (tasks.length === 1) return tasks[0].objective.slice(0, 120);
+  return `${tasks.length} tarefas: ${tasks.map((task) => task.objective.slice(0, 40)).join(" | ")}`;
+}
+
+/* ------------------------- historico da sessao ------------------------- */
+// O que os subagentes desta sessao fizeram: alimenta o `/agents`.
+const SESSION_RUNS = [];
+const MAX_RUNS = 50;
+
+function recordRun({ objective, tools = [], ok, ms = 0, steps = 0, report = "" }) {
+  SESSION_RUNS.push({
+    objective: String(objective || "(sem objetivo)"),
+    tools: [...tools],
+    ok: Boolean(ok),
+    ms: Number(ms) || 0,
+    steps: Number(steps) || 0,
+    report: String(report || ""),
+    at: new Date().toISOString(),
+  });
+  if (SESSION_RUNS.length > MAX_RUNS) SESSION_RUNS.splice(0, SESSION_RUNS.length - MAX_RUNS);
+  return SESSION_RUNS[SESSION_RUNS.length - 1];
+}
+
+function listRuns() {
+  return SESSION_RUNS.map((run) => ({ ...run }));
+}
+
+function clearRuns() {
+  SESSION_RUNS.length = 0;
+}
+
+module.exports = {
+  SUBAGENT_TOOL,
+  SUBAGENT_TOOL_NAME,
+  MAX_TASKS,
+  MAX_DEPTH,
+  DEFAULT_MAX_STEPS,
+  READ_ONLY_TOOLS,
+  ALL_LOCAL_TOOLS,
+  normalizeTasks,
+  allowedTools,
+  subagentPrompt,
+  describeSubagentCall,
+  recordRun,
+  listRuns,
+  clearRuns,
+};

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,
+};