@johpaz/hive 1.1.4 → 1.1.5

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@johpaz/hive",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Tu colmena de agentes IA. Local-first. Multi-canal. Open source. Construido desde Colombia para el mundo.",
   "bin": {
-    "hive": "packages/cli/src/index.ts"
+    "hive": "packages/cli/dist/hive-binary"
   },
   "main": "packages/core/src/index.ts",
   "repository": {
@@ -31,7 +31,7 @@
   "license": "MIT",
   "files": [
     "packages/core/",
-    "packages/cli/",
+    "packages/cli/dist/",
     "packages/mcp/",
     "packages/skills/",
     "packages/tools/",
@@ -48,13 +48,13 @@
     "dev": "HIVE_HOME=$HOME/.hive-dev HIVE_DEV=true bun run packages/cli/src/index.ts dev",
     "dev:keep": "HIVE_HOME=$HOME/.hive-dev HIVE_DEV=true HIVE_DEV_CLEAN=false bun run packages/cli/src/index.ts dev",
     "start": "bun run packages/cli/src/index.ts start",
+    "build": "cd packages/cli && bun build src/index.ts --compile --outfile dist/hive-binary",
     "test": "bun test",
     "test:ci": "bun test --coverage",
     "lint": "bunx tsc --noEmit",
-    "build": "echo 'No build needed - TypeScript is interpreted by Bun'",
     "build:binaries": "bun run scripts/build-binaries.ts",
     "bench": "bun run scripts/bench.ts",
-    "prepublishOnly": "bun run build"
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@ag-ui/core": "^0.0.46",

package/packages/cli/dist/commands/agent-run.d.ts

@@ -0,0 +1 @@
+export declare function agent(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/agent-run.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agent = agent;
+const p = __importStar(require("@clack/prompts"));
+const loader_1 = require("@johpaz/hive-core/config/loader");
+function getGatewayUrl(config) {
+    const gateway = config?.gateway;
+    const host = gateway?.host ?? "localhost";
+    const port = gateway?.port ?? 3000;
+    return `http://${host}:${port}`;
+}
+async function agent(subcommand, args) {
+    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) {
+    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);
+        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 = (0, loader_1.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.message}`);
+        console.log("   ¿Está corriendo el Gateway? Ejecuta: hive start");
+    }
+}
+async function executeWithStream(gatewayUrl, payload, spinner) {
+    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, payload, spinner) {
+    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();
+    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/packages/cli/dist/commands/agents.d.ts

@@ -0,0 +1 @@
+export declare function agents(subcommand: string | undefined, args: string[]): Promise<void>;

package/packages/cli/dist/commands/agents.js

@@ -0,0 +1,372 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agents = agents;
+const p = __importStar(require("@clack/prompts"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("@johpaz/hive-core/config/loader");
+const getAgentsPath = () => path.join((0, loader_1.getHiveDir)(), "agents");
+async function loadLifecycleAgents() {
+    const agents = [];
+    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));
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return agents;
+}
+async function agents(subcommand, args) {
+    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) {
+    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 = {
+        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, defaultVal) {
+    const result = await p.text({
+        message,
+        placeholder: defaultVal,
+        defaultValue: defaultVal,
+    });
+    if (p.isCancel(result)) {
+        p.cancel("Cancelled");
+        process.exit(0);
+    }
+    return result;
+}
+async function showLogs(agentId) {
+    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) {
+    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"));
+        state.state = "hibernated";
+        state.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) {
+    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"));
+        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, cascade) {
+    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"));
+        state.state = "terminated";
+        state.terminatedAt = new Date().toISOString();
+        state.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() {
+    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, 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) {
+    const config = (0, loader_1.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?.list || [];
+    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((0, loader_1.getHiveDir)(), "agents", id, "workspace");
+    const agentDir = path.join((0, loader_1.getHiveDir)(), "agents", id, "agent");
+    const newAgent = {
+        id: id,
+        name: name,
+        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) {
+    const config = (0, loader_1.loadConfig)();
+    const agentsList = config.agents?.list || [];
+    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?.filter((b) => (b.agentId || b.agent) === agent.id) || [];
+            console.log(`    Bindings:   ${bindings.length}`);
+        }
+        console.log();
+    }
+}
+async function removeAgent(id) {
+    if (!id) {
+        console.log("❌ Especifica el ID del agente: hive agents remove <id>");
+        return;
+    }
+    const config = (0, loader_1.loadConfig)();
+    const agentsList = config.agents?.list || [];
+    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/dist/commands/chat.d.ts

@@ -0,0 +1 @@
+export declare function chat(flags: string[]): Promise<void>;