@johpaz/hive-cli 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johpaz/hive-cli",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Hive CLI — Command line interface for the Hive AI Gateway",
   "bin": {
     "hive": "src/index.ts"
@@ -14,13 +14,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@clack/prompts": "^1.0.1",
-    "@johpaz/hive-core": "^1.0.7",
-    "@johpaz/hive-orchestrator": "workspace:*",
+    "@clack/prompts": "^",
+    "@johpaz/hive-core": "^1.0.10",
+    "@johpaz/hive-orchestrator": "^1.0.10",
     "js-yaml": "latest"
   },
   "devDependencies": {
     "typescript": "latest",
     "@types/bun": "latest"
   }
-}
+}

package/src/commands/agent-run.ts

@@ -0,0 +1,180 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+const HIVE_DIR = path.join(process.env.HOME || "", ".hive");
+const CONFIG_PATH = path.join(HIVE_DIR, "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 getGatewayUrl(config: Record<string, unknown> | null): string {
+  const gateway = config?.gateway as Record<string, unknown> | undefined;
+  const host = (gateway?.host as string) ?? "localhost";
+  const port = (gateway?.port as number) ?? 3000;
+  return `http://${host}:${port}`;
+}
+
+export async function agent(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "run":
+      await agentRun(args);
+      break;
+    default:
+      console.log(`
+Usage: hive agent <command>
+
+Commands:
+  run --message <text>     Ejecutar agente con mensaje
+  run --thinking <level>   Nivel de razonamiento (low/medium/high)
+  run --wait               Esperar respuesta completa
+`);
+  }
+}
+
+async function agentRun(args: string[]): Promise<void> {
+  const messageIndex = args.indexOf("--message");
+  const thinkingIndex = args.indexOf("--thinking");
+  const toolsIndex = args.indexOf("--tools");
+  const agentIndex = args.indexOf("--agent");
+  const waitIndex = args.indexOf("--wait");
+
+  if (messageIndex === -1) {
+    const msg = await p.text({
+      message: "Mensaje para el agente:",
+      placeholder: "Analiza el archivo README.md",
+      validate: (v) => (!v ? "El mensaje es requerido" : undefined),
+    });
+
+    if (p.isCancel(msg)) {
+      p.cancel("Cancelado");
+      return;
+    }
+
+    args.push("--message", msg as string);
+    return agentRun(args);
+  }
+
+  const message = args[messageIndex + 1];
+  const thinking = thinkingIndex !== -1 ? args[thinkingIndex + 1] : "medium";
+  const tools = toolsIndex !== -1 ? args[toolsIndex + 1] : "all";
+  const agentId = agentIndex !== -1 ? args[agentIndex + 1] : "main";
+  const wait = waitIndex !== -1;
+
+  if (!message) {
+    console.log("❌ Mensaje requerido");
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = getGatewayUrl(config);
+
+  const spinner = p.spinner();
+  spinner.start("Conectando con el agente...");
+
+  try {
+    if (wait) {
+      await executeWithStream(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    } else {
+      await executeAsync(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    }
+  } catch (error) {
+    spinner.stop("Error");
+    console.log(`❌ ${(error as Error).message}`);
+    console.log("   ¿Está corriendo el Gateway? Ejecuta: hive start");
+  }
+}
+
+async function executeWithStream(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: true }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  spinner.stop("Conectado");
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No se pudo obtener el stream");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let thinking = true;
+
+  process.stdout.write("\n");
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (!line.trim() || !line.startsWith("data: ")) continue;
+
+      try {
+        const data = JSON.parse(line.slice(6));
+
+        if (data.type === "thinking" && thinking) {
+          process.stdout.write(".");
+        } else if (data.type === "response") {
+          if (thinking) {
+            process.stdout.write("\n\n");
+            thinking = false;
+          }
+          process.stdout.write(data.content ?? "");
+        } else if (data.type === "tool_call") {
+          process.stdout.write(`\n[Tool: ${data.toolName}]`);
+        } else if (data.type === "complete") {
+          process.stdout.write("\n\n");
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+}
+
+async function executeAsync(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: false }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  const result = await response.json() as { taskId?: string; success: boolean };
+
+  spinner.stop("Enviado");
+
+  if (result.taskId) {
+    console.log(`✓ Tarea enviada: ${result.taskId}`);
+    console.log("  Usa `hive tasks list` para ver el estado");
+  } else {
+    console.log("✓ Tarea enviada");
+  }
+}

package/src/commands/gateway.ts

@@ -64,7 +64,7 @@ export async function start(flags: string[]): Promise<void> {
  ║   ██║  ██║██║ ╚████╔╝ ███████╗             ║
  ║   ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚══════╝             ║
  ║                                            ║
- ║   Personal AI Gateway — v1.0.7             ║
+ ║   Personal AI Gateway — v1.0.10             ║
  ╚════════════════════════════════════════════╝
 `);
 

package/src/commands/message.ts

@@ -0,0 +1,90 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+const HIVE_DIR = path.join(process.env.HOME || "", ".hive");
+const CONFIG_PATH = path.join(HIVE_DIR, "hive.yaml");
+
+interface MessageResult {
+  success: boolean;
+  messageId?: string;
+  error?: 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 getGatewayUrl(config: Record<string, unknown> | null): string {
+  const gateway = config?.gateway as Record<string, unknown> | undefined;
+  const host = (gateway?.host as string) ?? "localhost";
+  const port = (gateway?.port as number) ?? 3000;
+  return `http://${host}:${port}`;
+}
+
+export async function message(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "send":
+      await messageSend(args);
+      break;
+    default:
+      console.log(`
+Usage: hive message <command>
+
+Commands:
+  send --to <id> --content <text>  Enviar mensaje
+`);
+  }
+}
+
+async function messageSend(args: string[]): Promise<void> {
+  const toIndex = args.indexOf("--to");
+  const contentIndex = args.indexOf("--content");
+  const channelIndex = args.indexOf("--channel");
+
+  if (toIndex === -1 || contentIndex === -1) {
+    console.log("❌ Faltan parámetros requeridos");
+    console.log("   hive message send --to <id> --content <texto>");
+    return;
+  }
+
+  const to = args[toIndex + 1];
+  const content = args[contentIndex + 1];
+  const channel = channelIndex !== -1 ? args[channelIndex + 1] : "default";
+
+  if (!to || !content) {
+    console.log("❌ Parámetros inválidos");
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = getGatewayUrl(config);
+
+  try {
+    const response = await fetch(`${gatewayUrl}/api/messages/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ to, content, channel }),
+    });
+
+    if (!response.ok) {
+      console.log(`❌ Error: ${response.statusText}`);
+      return;
+    }
+
+    const result = (await response.json()) as MessageResult;
+
+    if (result.success) {
+      console.log(`✓ Mensaje enviado: ${result.messageId}`);
+    } else {
+      console.log(`❌ Error: ${result.error}`);
+    }
+  } catch (error) {
+    console.log(`❌ No se pudo conectar al Gateway: ${(error as Error).message}`);
+    console.log("   ¿Está corriendo? Ejecuta: hive start");
+  }
+}

package/src/commands/onboard.ts

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as yaml from "js-yaml";
 
-const VERSION = "1.0.8";
+const VERSION = "";
 
 const DEFAULT_MODELS: Record<string, string> = {
   anthropic: "claude-sonnet-4-6",
@@ -649,7 +649,7 @@ async function runUpdateWizard(configPath: string, existing: ExistingConfig): Pr
       const keyResult = await p.text({
         message: `API key de ${provider}:`,
         placeholder: API_KEY_PLACEHOLDERS[provider] || "sk-...",
-        validate: (v: string) => (!v || v.length < 10 ? "La key parece muy corta" : undefined),
+        validate: (v) => (!v || v.length < 10 ? "La key parece muy corta" : undefined),
       });
 
       if (p.isCancel(keyResult)) {

package/src/index.ts

@@ -13,8 +13,10 @@ import { doctor } from "./commands/doctor";
 import { securityAudit } from "./commands/security";
 import { installService } from "./commands/service";
 import { update } from "./commands/update";
+import { message } from "./commands/message";
+import { agent } from "./commands/agent-run";
 
-const VERSION = "1.0.7";
+const VERSION = "1.0.10";
 
 const HELP = `
 🐝 Hive — Personal AI Gateway v${VERSION}
@@ -30,6 +32,10 @@ Commands:
   chat [--agent <id>]        Chat directo en terminal
   logs [--follow] [--level]  Ver logs del Gateway
 
+  message send --to <id> --content <text>
+                             Enviar mensaje por canal
+  agent run --message <text> Ejecutar agente con mensaje
+
   agents add <id>            Crear nuevo agente
   agents list [--bindings]   Listar agentes
   agents remove <id>         Eliminar agente
@@ -73,6 +79,8 @@ Examples:
   hive onboard               Configurar Hive por primera vez
   hive start                 Arrancar el Gateway
   hive chat                  Chatear con el agente en terminal
+  hive message send --to 123 --content "Hola"
+  hive agent run --message "Analiza README.md" --wait
   hive agents add work       Crear agente "work"
   hive mcp add               Añadir servidor MCP
   hive doctor                Diagnosticar problemas
@@ -110,6 +118,12 @@ async function main(): Promise<void> {
     case "logs":
       await logs(flags);
       break;
+    case "message":
+      await message(subcommand, args.slice(2));
+      break;
+    case "agent":
+      await agent(subcommand, args.slice(2));
+      break;
     case "agents":
       await agents(subcommand, args.slice(2));
       break;