@johpaz/hive-cli 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-cli",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Hive CLI — Command line interface for the Hive AI Gateway",
   "bin": {
     "hive": "src/index.ts"
@@ -14,7 +14,9 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@johpaz/hive-core": "^1.0.3"
+    "@clack/prompts": "^1.0.1",
+    "@johpaz/hive-core": "^1.0.4",
+    "js-yaml": "latest"
   },
   "devDependencies": {
     "typescript": "latest",

package/src/commands/agents.ts

@@ -0,0 +1,187 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+const CONFIG_PATH = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+
+interface AgentConfig {
+  id: string;
+  name: string;
+  default?: boolean;
+  workspace: string;
+  agentDir: string;
+}
+
+function loadConfig(): Record<string, unknown> | null {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return yaml.load(content) as Record<string, unknown>;
+}
+
+function saveConfig(config: Record<string, unknown>): void {
+  fs.writeFileSync(CONFIG_PATH, yaml.dump(config, { lineWidth: -1 }), "utf-8");
+}
+
+export async function agents(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "add":
+      await addAgent(args[0]);
+      break;
+    case "list":
+      await listAgents(args.includes("--bindings"));
+      break;
+    case "remove":
+      await removeAgent(args[0]);
+      break;
+    default:
+      console.log(`
+Usage: hive agents <command>
+
+Commands:
+  add <id>           Crear nuevo agente
+  list [--bindings]  Listar agentes
+  remove <id>        Eliminar agente
+`);
+  }
+}
+
+async function addAgent(id: string | undefined): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  if (!id) {
+    const result = await p.text({
+      message: "ID del nuevo agente:",
+      placeholder: "work",
+      validate: (v) => (!v ? "El ID es requerido" : undefined),
+    });
+    if (p.isCancel(result)) {
+      p.cancel("Cancelado");
+      return;
+    }
+    id = result;
+  }
+
+  const agentsList = ((config.agents as Record<string, unknown>)?.list as AgentConfig[]) || [];
+  if (agentsList.find((a) => a.id === id)) {
+    console.log(`❌ Ya existe un agente con ID "${id}"`);
+    return;
+  }
+
+  const name = await p.text({
+    message: "Nombre del agente:",
+    placeholder: id,
+    defaultValue: id,
+  });
+
+  if (p.isCancel(name)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const workspace = path.join(process.env.HOME || "", ".hive", "agents", id as string, "workspace");
+  const agentDir = path.join(process.env.HOME || "", ".hive", "agents", id as string, "agent");
+
+  const newAgent: AgentConfig = {
+    id: id as string,
+    name: name as string,
+    workspace,
+    agentDir,
+  };
+
+  fs.mkdirSync(workspace, { recursive: true });
+  fs.mkdirSync(agentDir, { recursive: true });
+
+  const soulPath = path.join(agentDir, "SOUL.md");
+  if (!fs.existsSync(soulPath)) {
+    fs.writeFileSync(soulPath, `# ${name} — Soul\n\nEres ${name}, un agente especializado.\n`, "utf-8");
+  }
+
+  const userPath = path.join(agentDir, "USER.md");
+  if (!fs.existsSync(userPath)) {
+    fs.writeFileSync(userPath, `# User Profile\n\nNotas sobre el usuario.\n`, "utf-8");
+  }
+
+  agentsList.push(newAgent);
+  if (!config.agents) config.agents = {};
+  (config.agents as Record<string, unknown>).list = agentsList;
+  saveConfig(config);
+
+  console.log(`✅ Agente "${id}" creado`);
+  console.log(`   Workspace: ${workspace}`);
+  console.log(`   AgentDir:  ${agentDir}`);
+}
+
+async function listAgents(showBindings: boolean): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const agentsList = ((config.agents as Record<string, unknown>)?.list as AgentConfig[]) || [];
+
+  if (agentsList.length === 0) {
+    console.log("No hay agentes configurados");
+    return;
+  }
+
+  console.log("\n🐝 Agentes:\n");
+  for (const agent of agentsList) {
+    const defaultTag = agent.default ? " (default)" : "";
+    console.log(`  ${agent.id}${defaultTag}`);
+    console.log(`    Nombre:     ${agent.name}`);
+    console.log(`    Workspace:  ${agent.workspace}`);
+    if (showBindings) {
+      const bindings = (config.bindings as Array<{ agent: string }>)?.filter((b) => b.agent === agent.id) || [];
+      console.log(`    Bindings:   ${bindings.length}`);
+    }
+    console.log();
+  }
+}
+
+async function removeAgent(id: string | undefined): Promise<void> {
+  if (!id) {
+    console.log("❌ Especifica el ID del agente: hive agents remove <id>");
+    return;
+  }
+
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración.");
+    return;
+  }
+
+  const agentsList = ((config.agents as Record<string, unknown>)?.list as AgentConfig[]) || [];
+  const agent = agentsList.find((a) => a.id === id);
+
+  if (!agent) {
+    console.log(`❌ No existe el agente "${id}"`);
+    return;
+  }
+
+  if (agent.default) {
+    console.log("❌ No puedes eliminar el agente por defecto");
+    return;
+  }
+
+  const confirm = await p.confirm({
+    message: `¿Eliminar el agente "${id}"?`,
+    initialValue: false,
+  });
+
+  if (p.isCancel(confirm) || !confirm) {
+    console.log("Cancelado");
+    return;
+  }
+
+  const newAgentsList = agentsList.filter((a) => a.id !== id);
+  (config.agents as Record<string, unknown>).list = newAgentsList;
+  saveConfig(config);
+
+  console.log(`✅ Agente "${id}" eliminado`);
+}

package/src/commands/chat.ts

@@ -0,0 +1,140 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { spawn } from "child_process";
+import * as readline from "readline";
+
+const CONFIG_PATH = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+
+function loadConfig(): Record<string, unknown> | null {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return yaml.load(content) as Record<string, unknown>;
+}
+
+export async function chat(flags: string[]): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const agentId = flags.find((f) => f.startsWith("--agent"))?.split("=")[1] || 
+                  flags[flags.indexOf("--agent") + 1] || 
+                  "main";
+
+  console.log(`\n🐝 Chat con agente: ${agentId}`);
+  console.log("   Escribe /exit para salir, /new para nueva sesión\n");
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const question = (prompt: string): Promise<string> => {
+    return new Promise((resolve) => {
+      rl.question(prompt, resolve);
+    });
+  };
+
+  const messages: Array<{ role: string; content: string }> = [];
+
+  while (true) {
+    const input = await question("> ");
+    const trimmed = input.trim();
+
+    if (!trimmed) continue;
+
+    if (trimmed === "/exit" || trimmed === "/quit") {
+      console.log("👋 ¡Hasta luego!");
+      rl.close();
+      break;
+    }
+
+    if (trimmed === "/new") {
+      messages.length = 0;
+      console.log("📝 Nueva sesión iniciada\n");
+      continue;
+    }
+
+    if (trimmed === "/help") {
+      console.log(`
+Comandos disponibles:
+  /exit, /quit  - Salir del chat
+  /new          - Iniciar nueva sesión
+  /help         - Mostrar esta ayuda
+`);
+      continue;
+    }
+
+    messages.push({ role: "user", content: trimmed });
+
+    console.log("\n🤖 Pensando...\n");
+
+    try {
+      const response = await callLLM(config, messages);
+      messages.push({ role: "assistant", content: response });
+      console.log(`\n${response}\n`);
+    } catch (error) {
+      console.log(`❌ Error: ${(error as Error).message}\n`);
+    }
+  }
+}
+
+async function callLLM(config: Record<string, unknown>, messages: Array<{ role: string; content: string }>): Promise<string> {
+  const models = config.models as Record<string, unknown> | undefined;
+  const provider = models?.defaultProvider as string || "anthropic";
+  const defaults = models?.defaults as Record<string, string> | undefined;
+  const model = defaults?.default || defaults?.[provider] || "claude-sonnet-4-5";
+  const providers = models?.providers as Record<string, Record<string, unknown>> | undefined;
+  const providerConfig = providers?.[provider] as Record<string, unknown> | undefined;
+  const apiKey = providerConfig?.apiKey as string || process.env.ANTHROPIC_API_KEY || "";
+
+  if (provider === "anthropic") {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "anthropic-dangerous-direct-browser-access": "true",
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4096,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+
+    const data = (await response.json()) as { content: Array<{ text: string }> };
+    return data.content[0]?.text || "Sin respuesta";
+  }
+
+  if (provider === "openai") {
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+
+    const data = (await response.json()) as { choices: Array<{ message: { content: string } }> };
+    return data.choices[0]?.message?.content || "Sin respuesta";
+  }
+
+  return "Proveedor no soportado en modo chat. Usa 'hive start' para el Gateway completo.";
+}

package/src/commands/config.ts

@@ -0,0 +1,168 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { spawn } from "child_process";
+
+const CONFIG_PATH = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+
+function loadConfig(): Record<string, unknown> | null {
+  if (!fs.existsSync(CONFIG_PATH)) return null;
+  const content = fs.readFileSync(CONFIG_PATH, "utf-8");
+  return yaml.load(content) as Record<string, unknown>;
+}
+
+function saveConfig(config: Record<string, unknown>): void {
+  fs.writeFileSync(CONFIG_PATH, yaml.dump(config, { lineWidth: -1 }), "utf-8");
+}
+
+function redactSecrets(obj: unknown, depth = 0): unknown {
+  if (depth > 10) return obj;
+  if (typeof obj !== "object" || obj === null) return obj;
+
+  const sensitiveKeys = ["apiKey", "token", "botToken", "password", "secret", "key"];
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => redactSecrets(item, depth + 1));
+  }
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+      result[key] = "***REDACTED***";
+    } else {
+      result[key] = redactSecrets(value, depth + 1);
+    }
+  }
+  return result;
+}
+
+export async function config(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "get":
+      await getConfig(args[0]);
+      break;
+    case "set":
+      await setConfig(args[0], args[1]);
+      break;
+    case "show":
+      await showConfig();
+      break;
+    case "edit":
+      await editConfig();
+      break;
+    default:
+      console.log(`
+Usage: hive config <command>
+
+Commands:
+  get <key>         Leer valor de config
+  set <key> <value> Escribir valor de config
+  show              Mostrar config completa
+  edit              Editar hive.yaml en $EDITOR
+`);
+  }
+}
+
+async function getConfig(key: string | undefined): Promise<void> {
+  if (!key) {
+    console.log("❌ Especifica la clave: hive config get <key>");
+    return;
+  }
+
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const keys = key.split(".");
+  let value: unknown = config;
+
+  for (const k of keys) {
+    if (typeof value === "object" && value !== null && k in value) {
+      value = (value as Record<string, unknown>)[k];
+    } else {
+      console.log(`❌ Clave no encontrada: ${key}`);
+      return;
+    }
+  }
+
+  if (typeof value === "object") {
+    console.log(JSON.stringify(value, null, 2));
+  } else {
+    console.log(value);
+  }
+}
+
+async function setConfig(key: string | undefined, value: string | undefined): Promise<void> {
+  if (!key) {
+    console.log("❌ Especifica la clave: hive config set <key> <value>");
+    return;
+  }
+
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const keys = key.split(".");
+  let obj: Record<string, unknown> = config;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (!(k in obj)) {
+      obj[k] = {};
+    }
+    obj = obj[k] as Record<string, unknown>;
+  }
+
+  const lastKey = keys[keys.length - 1];
+  
+  let parsedValue: unknown = value;
+  if (value === "true") parsedValue = true;
+  else if (value === "false") parsedValue = false;
+  else if (value && !isNaN(Number(value))) parsedValue = Number(value);
+  else if (value?.startsWith("[") || value?.startsWith("{")) {
+    try {
+      parsedValue = JSON.parse(value as string);
+    } catch {
+      parsedValue = value;
+    }
+  }
+
+  obj[lastKey] = parsedValue;
+  saveConfig(config);
+
+  console.log(`✅ ${key} = ${JSON.stringify(parsedValue)}`);
+}
+
+async function showConfig(): Promise<void> {
+  const config = loadConfig();
+  if (!config) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const redacted = redactSecrets(config);
+  console.log(yaml.dump(redacted, { lineWidth: -1 }));
+}
+
+async function editConfig(): Promise<void> {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    console.log("❌ No hay configuración. Ejecuta: hive onboard");
+    return;
+  }
+
+  const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+
+  const child = spawn(editor, [CONFIG_PATH], {
+    stdio: "inherit",
+    shell: true,
+  });
+
+  child.on("exit", () => {
+    console.log("\n✅ Configuración editada");
+  });
+}

package/src/commands/cron.ts

@@ -0,0 +1,157 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+const CONFIG_PATH = path.join(process.env.HOME || "", ".hive", "hive.yaml");
+const CRON_DIR = path.join(process.env.HOME || "", ".hive", "cron");
+const CRON_DB = path.join(CRON_DIR, "jobs.json");
+
+interface CronJob {
+  id: string;
+  schedule: string;
+  command: string;
+  enabled: boolean;
+  lastRun?: string;
+  nextRun?: string;
+}
+
+function loadJobs(): CronJob[] {
+  if (!fs.existsSync(CRON_DB)) return [];
+  return JSON.parse(fs.readFileSync(CRON_DB, "utf-8"));
+}
+
+function saveJobs(jobs: CronJob[]): void {
+  if (!fs.existsSync(CRON_DIR)) {
+    fs.mkdirSync(CRON_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CRON_DB, JSON.stringify(jobs, null, 2));
+}
+
+export async function cron(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "list":
+      await listCron();
+      break;
+    case "add":
+      await addCron();
+      break;
+    case "remove":
+      await removeCron(args[0]);
+      break;
+    case "logs":
+      await cronLogs();
+      break;
+    default:
+      console.log(`
+Usage: hive cron <command>
+
+Commands:
+  list        Listar cron jobs
+  add         Añadir cron job
+  remove <id> Eliminar cron job
+  logs        Ver logs de cron
+`);
+  }
+}
+
+async function listCron(): Promise<void> {
+  const jobs = loadJobs();
+
+  if (jobs.length === 0) {
+    console.log("No hay cron jobs configurados");
+    return;
+  }
+
+  console.log("\n⏰ Cron Jobs:\n");
+
+  for (const job of jobs) {
+    const status = job.enabled ? "✅ Activo" : "⏸️  Pausado";
+    console.log(`  ${job.id}`);
+    console.log(`    Estado:    ${status}`);
+    console.log(`    Schedule:  ${job.schedule}`);
+    console.log(`    Comando:   ${job.command}`);
+    if (job.lastRun) {
+      console.log(`    Última:    ${job.lastRun}`);
+    }
+    console.log();
+  }
+}
+
+async function addCron(): Promise<void> {
+  const id = await p.text({
+    message: "ID del cron job:",
+    placeholder: "daily-report",
+    validate: (v) => (!v ? "El ID es requerido" : undefined),
+  });
+
+  if (p.isCancel(id)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const schedule = await p.text({
+    message: "Schedule (cron expression):",
+    placeholder: "0 9 * * *",
+    validate: (v) => (!v ? "El schedule es requerido" : undefined),
+  });
+
+  if (p.isCancel(schedule)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const command = await p.text({
+    message: "Comando a ejecutar:",
+    placeholder: "hive chat --agent work 'Genera el reporte diario'",
+    validate: (v) => (!v ? "El comando es requerido" : undefined),
+  });
+
+  if (p.isCancel(command)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const jobs = loadJobs();
+  jobs.push({
+    id: id as string,
+    schedule: schedule as string,
+    command: command as string,
+    enabled: true,
+  });
+  saveJobs(jobs);
+
+  console.log(`✅ Cron job "${id}" creado`);
+}
+
+async function removeCron(id: string | undefined): Promise<void> {
+  if (!id) {
+    console.log("❌ Especifica el ID: hive cron remove <id>");
+    return;
+  }
+
+  const jobs = loadJobs();
+  const index = jobs.findIndex((j) => j.id === id);
+
+  if (index === -1) {
+    console.log(`❌ Cron job no encontrado: ${id}`);
+    return;
+  }
+
+  jobs.splice(index, 1);
+  saveJobs(jobs);
+
+  console.log(`✅ Cron job "${id}" eliminado`);
+}
+
+async function cronLogs(): Promise<void> {
+  const logFile = path.join(CRON_DIR, "cron.log");
+
+  if (!fs.existsSync(logFile)) {
+    console.log("No hay logs de cron");
+    return;
+  }
+
+  const content = fs.readFileSync(logFile, "utf-8");
+  console.log(content);
+}