@johpaz/hive-agents 0.0.34 → 0.0.36

package/packages/cli/src/commands/agents.ts

@@ -0,0 +1,398 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig, getHiveDir } from "@johpaz/hive-agents-core/config/loader";
+
+const getAgentsPath = () => path.join(getHiveDir(), "agents");
+
+interface AgentConfig {
+  id: string;
+  name: string;
+  default?: boolean;
+  workspace: string;
+  agentDir: string;
+}
+
+interface AgentState {
+  id: string;
+  name: string;
+  type: "primary" | "child" | "sibling";
+  state: "active" | "hibernated" | "terminated";
+  purpose: string;
+  parentId?: string;
+  childrenIds: string[];
+  workspacePath: string;
+  createdAt: string;
+  lastActivity: string;
+  capabilities: string[];
+}
+
+async function loadLifecycleAgents(): Promise<AgentState[]> {
+  const agents: AgentState[] = [];
+  try {
+    if (!fs.existsSync(getAgentsPath())) return [];
+    const entries = fs.readdirSync(getAgentsPath(), { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const statePath = path.join(getAgentsPath(), entry.name, "state.json");
+      try {
+        const content = fs.readFileSync(statePath, "utf-8");
+        agents.push(JSON.parse(content) as AgentState);
+      } catch { }
+    }
+  } catch { }
+  return agents;
+}
+
+export async function agents(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "add":
+      await addAgent(args[0]);
+      break;
+    case "create":
+      await createAgent(args);
+      break;
+    case "list":
+    case "ls":
+      await listAgents(args.includes("--bindings"));
+      break;
+    case "logs":
+      await showLogs(args[0]);
+      break;
+    case "hibernate":
+      await hibernateAgent(args[0]);
+      break;
+    case "wake":
+      await wakeAgent(args[0]);
+      break;
+    case "terminate":
+    case "kill":
+      await terminateAgent(args[0], args.includes("--cascade"));
+      break;
+    case "tree":
+      await showTree();
+      break;
+    case "remove":
+      await removeAgent(args[0]);
+      break;
+    default:
+      console.log(`
+Usage: hive agents <command> [arguments]
+
+Commands:
+  list, ls                    List all agents
+  add <id>                    Create agent (legacy)
+  create                      Create agent with new lifecycle system
+  logs <agent-id>             Show agent logs
+  hibernate <agent-id>        Put agent to sleep
+  wake <agent-id>             Wake a hibernated agent
+  terminate <agent-id> [--cascade]  Terminate an agent
+  tree                        Show agent hierarchy tree
+  remove <id>                 Remove agent (legacy)
+
+Examples:
+  hive agents list
+  hive agents create
+  hive agents tree
+  hive agents hibernate agent-abc123
+  hive agents wake agent-abc123
+  hive agents terminate agent-abc123 --cascade
+`);
+  }
+}
+
+async function createAgent(args: string[]): Promise<void> {
+  const name = args[0] || await promptInput("Agent name:", `agent-${Date.now()}`);
+  const purpose = args[1] || await promptInput("Purpose:", "General AI assistant");
+
+  const agentId = `agent-${crypto.randomUUID().slice(0, 8)}`;
+  const workspacePath = path.join(getAgentsPath(), agentId);
+
+  fs.mkdirSync(path.join(workspacePath, "memory"), { recursive: true });
+  fs.mkdirSync(path.join(workspacePath, "skills"), { recursive: true });
+  fs.mkdirSync(path.join(workspacePath, "logs"), { recursive: true });
+
+  const soulMd = `# SOUL.md - ${name}
+
+## Identity
+
+I am ${name}, created to ${purpose.toLowerCase()}.
+
+## Personality
+
+- Helpful and responsive
+- Clear communicator
+- Adaptable to user needs
+`;
+
+  const ethicsMd = `# ETHICS.md
+
+## Core Principles
+
+1. Honesty - Never deceive the user
+2. Privacy - Protect user data
+3. Safety - Prevent harm
+4. Consent - Ask before significant actions
+`;
+
+  fs.writeFileSync(path.join(workspacePath, "SOUL.md"), soulMd);
+  fs.writeFileSync(path.join(workspacePath, "ETHICS.md"), ethicsMd);
+  fs.writeFileSync(path.join(workspacePath, "USER.md"), "# USER.md\n\n## Preferences\n\n");
+
+  const state: AgentState = {
+    id: agentId,
+    name,
+    type: "sibling",
+    state: "active",
+    purpose,
+    childrenIds: [],
+    workspacePath,
+    createdAt: new Date().toISOString(),
+    lastActivity: new Date().toISOString(),
+    capabilities: ["general"],
+  };
+
+  fs.writeFileSync(path.join(workspacePath, "state.json"), JSON.stringify(state, null, 2));
+
+  console.log(`\n✅ Agent created: ${name} (${agentId})`);
+  console.log(`   Workspace: ${workspacePath}\n`);
+}
+
+async function promptInput(message: string, defaultVal: string): Promise<string> {
+  const result = await p.text({
+    message,
+    placeholder: defaultVal,
+    defaultValue: defaultVal,
+  });
+  if (p.isCancel(result)) {
+    p.cancel("Cancelled");
+    process.exit(0);
+  }
+  return result as string;
+}
+
+async function showLogs(agentId: string | undefined): Promise<void> {
+  if (!agentId) {
+    console.log("Usage: hive agents logs <agent-id>");
+    return;
+  }
+
+  const logPath = path.join(getAgentsPath(), agentId, "logs");
+  try {
+    const files = fs.readdirSync(logPath).filter((f) => f.endsWith(".log")).sort().reverse();
+    if (files.length === 0) {
+      console.log("\n📋 No logs found.\n");
+      return;
+    }
+    const content = fs.readFileSync(path.join(logPath, files[0]!), "utf-8");
+    console.log(`\n📋 Logs for ${agentId}:\n`);
+    console.log(content.slice(-3000));
+  } catch {
+    console.log(`\n❌ Agent not found: ${agentId}\n`);
+  }
+}
+
+async function hibernateAgent(agentId: string | undefined): Promise<void> {
+  if (!agentId) {
+    console.log("Usage: hive agents hibernate <agent-id>");
+    return;
+  }
+
+  const statePath = path.join(getAgentsPath(), agentId, "state.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8")) as AgentState;
+    state.state = "hibernated";
+    (state as any).hibernatedAt = new Date().toISOString();
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    console.log(`\n💤 Agent ${state.name} hibernated.\n`);
+  } catch {
+    console.log(`\n❌ Agent not found: ${agentId}\n`);
+  }
+}
+
+async function wakeAgent(agentId: string | undefined): Promise<void> {
+  if (!agentId) {
+    console.log("Usage: hive agents wake <agent-id>");
+    return;
+  }
+
+  const statePath = path.join(getAgentsPath(), agentId, "state.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8")) as AgentState;
+    state.state = "active";
+    state.lastActivity = new Date().toISOString();
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    console.log(`\n⚡ Agent ${state.name} activated.\n`);
+  } catch {
+    console.log(`\n❌ Agent not found: ${agentId}\n`);
+  }
+}
+
+async function terminateAgent(agentId: string | undefined, cascade: boolean): Promise<void> {
+  if (!agentId) {
+    console.log("Usage: hive agents terminate <agent-id> [--cascade]");
+    return;
+  }
+
+  const statePath = path.join(getAgentsPath(), agentId, "state.json");
+  try {
+    const state = JSON.parse(fs.readFileSync(statePath, "utf-8")) as AgentState;
+    state.state = "terminated";
+    (state as any).terminatedAt = new Date().toISOString();
+    (state as any).terminationReason = "User requested";
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    console.log(`\n⚫ Agent ${state.name} terminated.\n`);
+
+    if (cascade && state.childrenIds?.length > 0) {
+      for (const childId of state.childrenIds) {
+        await terminateAgent(childId, true);
+      }
+    }
+  } catch {
+    console.log(`\n❌ Agent not found: ${agentId}\n`);
+  }
+}
+
+async function showTree(): Promise<void> {
+  const agents = await loadLifecycleAgents();
+  if (agents.length === 0) {
+    console.log("\n📋 No agents found. Run 'hive onboard' to create your first agent.\n");
+    return;
+  }
+
+  const primaries = agents.filter((a) => a.type === "primary" && a.state !== "terminated");
+
+  const printTree = (agent: AgentState, indent = "") => {
+    const icon = agent.state === "active" ? "🟢" : agent.state === "hibernated" ? "💤" : "⚫";
+    console.log(`${indent}${icon} ${agent.name} (${agent.id.slice(0, 12)}...)`);
+    const children = agents.filter((a) => a.parentId === agent.id);
+    for (const child of children) {
+      printTree(child, indent + "  ");
+    }
+  };
+
+  console.log("\n🌳 Agent Hierarchy:\n");
+  for (const primary of primaries) {
+    printTree(primary);
+  }
+  console.log("");
+}
+
+async function addAgent(id: string | undefined): Promise<void> {
+  const config = loadConfig();
+
+  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(getHiveDir(), "agents", id as string, "workspace");
+  const agentDir = path.join(getHiveDir(), "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);
+
+  console.log(`✅ Agente "${id}" creado`);
+  console.log(`   Workspace: ${workspace}`);
+  console.log(`   AgentDir:  ${agentDir}`);
+}
+
+async function listAgents(showBindings: boolean): Promise<void> {
+  const config = loadConfig();
+  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 as any).bindings as any[])?.filter((b: any) => (b.agentId || 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();
+  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;
+  }
+
+  console.log(`✅ Agente "${id}" eliminado`);
+}

package/packages/cli/src/commands/chat.ts

@@ -0,0 +1,142 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+import * as readline from "readline";
+import { loadConfig, getHiveDir } from "@johpaz/hive-agents-core/config/loader";
+
+const getHiveDirConst = () => getHiveDir();
+
+export async function chat(flags: string[]): Promise<void> {
+  const config = loadConfig();
+  const HIVE_DIR = getHiveDirConst();
+
+  if (!fs.existsSync(HIVE_DIR)) {
+    console.log("❌ Directorio Hive no encontrado. 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: any, 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 as any)?.defaults as Record<string, string> | undefined;
+  const model = defaults?.default || (defaults as any)?.[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;
+
+  // Try to get API key from config, then process.env
+  const apiKey = (providerConfig?.apiKey as string) ||
+    process.env[`${provider.toUpperCase()}_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) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Anthropic API error: ${response.status} - ${JSON.stringify(errorData)}`);
+    }
+
+    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) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`OpenAI API error: ${response.status} - ${JSON.stringify(errorData)}`);
+    }
+
+    const data = (await response.json()) as { choices: Array<{ message: { content: string } }> };
+    return data.choices[0]?.message?.content || "Sin respuesta";
+  }
+
+  return `Proveedor '${provider}' no soportado en modo chat CLI. Usa 'hive start' para el Gateway completo.`;
+}

package/packages/cli/src/commands/config.ts

@@ -0,0 +1,49 @@
+import * as p from "@clack/prompts";
+import { loadConfig } from "@johpaz/hive-agents-core/config/loader";
+
+export async function config(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "show":
+      await showConfig();
+      break;
+    case "edit":
+      console.log("Configura Hive a través de variables de entorno o la base de datos.");
+      break;
+    default:
+      console.log(`
+Usage: hive config <command>
+
+Commands:
+  show      Mostrar la configuración actual (redactada)
+  edit      (Deshabilitado) Edición manual de configuración
+`);
+  }
+}
+
+function redactSecrets(obj: any, depth = 0): any {
+  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: any = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (sensitiveKeys.some((sk) => key.toLowerCase().includes(sk.toLowerCase()))) {
+      result[key] = "***REDACTED***";
+    } else {
+      result[key] = redactSecrets(value, depth + 1);
+    }
+  }
+  return result;
+}
+
+async function showConfig(): Promise<void> {
+  const config = loadConfig();
+  console.log("\n⚙️  Configuración Actual (Redactada):\n");
+  console.log(JSON.stringify(redactSecrets(config), null, 2));
+  console.log();
+}