@johpaz/hive-sdk 0.0.14 → 0.0.16

package/package.json

@@ -1,113 +1,69 @@
 {
   "name": "@johpaz/hive-sdk",
-  "version": "0.0.14",
-  "description": "Hive SDK — Crear agentes IA con todo incluido: agentes, tools, skills, MCP, TTS, canales, gateway y más.",
+  "version": "0.0.16",
+  "private": false,
+  "description": "Hive SDK — The Agent Harness SDK. Build, deploy, and scale AI agent applications with multi-channel support, context engineering, and swarm orchestration.",
   "license": "MIT",
-  "type": "module",
-  "scripts": {
-    "build": "bun run --cwd ../.. build"
-  },
-  "main": "./src/index.ts",
-  "module": "./src/index.ts",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
-    },
-    "./agents": {
-      "types": "./src/agents.ts",
-      "default": "./src/agents.ts"
-    },
-    "./tools": {
-      "types": "./src/tools.ts",
-      "default": "./src/tools.ts"
-    },
-    "./skills": {
-      "types": "./src/skills.ts",
-      "default": "./src/skills.ts"
-    },
-    "./mcp": {
-      "types": "./src/mcp.ts",
-      "default": "./src/mcp.ts"
-    },
-    "./tts": {
-      "types": "./src/tts.ts",
-      "default": "./src/tts.ts"
-    },
-    "./channels": {
-      "types": "./src/channels.ts",
-      "default": "./src/channels.ts"
-    },
-    "./storage": {
-      "types": "./src/storage.ts",
-      "default": "./src/storage.ts"
-    },
-    "./gateway": {
-      "types": "./src/gateway.ts",
-      "default": "./src/gateway.ts"
-    },
-    "./scheduler": {
-      "types": "./src/scheduler.ts",
-      "default": "./src/scheduler.ts"
-    },
-    "./events": {
-      "types": "./src/events.ts",
-      "default": "./src/events.ts"
-    },
-    "./state": {
-      "types": "./src/state.ts",
-      "default": "./src/state.ts"
-    },
-    "./security": {
-      "types": "./src/security.ts",
-      "default": "./src/security.ts"
-    },
-    "./config": {
-      "types": "./src/config.ts",
-      "default": "./src/config.ts"
-    },
-    "./canvas": {
-      "types": "./src/canvas.ts",
-      "default": "./src/canvas.ts"
-    },
-    "./voice": {
-      "types": "./src/voice.ts",
-      "default": "./src/voice.ts"
-    },
-    "./multimodal": {
-      "types": "./src/multimodal.ts",
-      "default": "./src/multimodal.ts"
-    },
-    "./utils": {
-      "types": "./src/utils.ts",
-      "default": "./src/utils.ts"
-    },
-    "./types": {
-      "types": "./src/types.ts",
-      "default": "./src/types.ts"
-    }
+  "homepage": "https://github.com/johpaz/hive-sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/johpaz/hive-sdk.git"
   },
-  "peerDependencies": {
-    "typescript": "6.0.2"
-  },
-  "peerDependenciesMeta": {
-    "typescript": {
-      "optional": true
-    }
+  "bugs": {
+    "url": "https://github.com/johpaz/hive-sdk/issues"
   },
   "keywords": [
-    "hive",
-    "sdk",
-    "agents",
     "ai",
+    "agent",
     "llm",
-    "mcp",
-    "tts",
+    "harness",
+    "context-engineering",
+    "fts5",
+    "swarm",
+    "ace",
+    "bun",
+    "langchain-alternative",
     "multi-channel",
-    "telegram",
-    "discord",
-    "whatsapp",
-    "slack"
-  ]
-}
+    "gateway"
+  ],
+  "main": "./packages/core/src/index.ts",
+  "types": "./packages/core/src/index.ts",
+  "bin": {
+    "hive": "./packages/cli/bin/hive"
+  },
+  "workspaces": [
+    "packages/core",
+    "packages/cli"
+  ],
+  "scripts": {
+    "build": "bun run typecheck",
+    "typecheck": "tsc --build --force",
+    "test": "bun test",
+    "prepublish": "echo 'No build needed - Bun runs TypeScript directly'"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@google/genai": "^1.43.0",
+    "@modelcontextprotocol/sdk": "latest",
+    "@sapphire/snowflake": "latest",
+    "async-mutex": "^0.5.0",
+    "cron-parser": "^5.5.0",
+    "croner": "^10.0.1",
+    "docx": "^9.6.1",
+    "groq-sdk": "^0.37.0",
+    "jszip": "^3.10.1",
+    "pdf-lib": "^1.17.1",
+    "mammoth": "^1.12.0",
+    "ollama": "^0.6.3",
+    "openai": "^6.18.0",
+    "pdfjs-dist": "^5.6.205",
+    "pptxgenjs": "^4.0.1",
+    "toon-format-parser": "^1.1.0",
+    "xlsx": "^0.18.5",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.13",
+    "typescript": "6.0.2"
+  }
+}

package/packages/cli/bin/hive

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../src/index.ts");

package/packages/cli/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@hive/cli",
+  "version": "0.0.15",
+  "description": "Hive CLI — init, run, test, trace",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "hive": "./src/index.ts"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@hive/core": "workspace:*"
+  }
+}

package/packages/cli/src/commands/add-skill.ts

@@ -0,0 +1,42 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+
+async function runAddSkill() {
+  const skillName = process.argv[3];
+
+  if (!skillName) {
+    console.error("Usage: hive add-skill <name>");
+    process.exit(1);
+  }
+
+  const skillsDir = join(process.cwd(), "src", "skills");
+  const filePath = join(skillsDir, `${skillName}.ts`);
+
+  if (existsSync(filePath)) {
+    console.error(`Skill '${skillName}' already exists.`);
+    process.exit(1);
+  }
+
+  mkdirSync(skillsDir, { recursive: true });
+
+  const content = `import { defineSkill } from "@johpaz/hive-sdk";
+
+export const ${skillName}Skill = defineSkill({
+  name: "${skillName}",
+  description: "Description of what ${skillName} skill does.",
+  steps: [
+    {
+      name: "step-1",
+      description: "First step of the skill",
+      tool: "notify",
+    },
+  ],
+});
+`;
+
+  writeFileSync(filePath, content);
+  console.log(`✅ Created skill: ${filePath}`);
+}
+
+runAddSkill();

package/packages/cli/src/commands/add-tool.ts

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+
+function toPascalCase(str: string): string {
+  return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toUpperCase());
+}
+
+async function runAddTool() {
+  const toolName = process.argv[3];
+
+  if (!toolName) {
+    console.error("Usage: hive add-tool <name>");
+    process.exit(1);
+  }
+
+  const toolsDir = join(process.cwd(), "src", "tools");
+  const filePath = join(toolsDir, `${toolName}.ts`);
+
+  if (existsSync(filePath)) {
+    console.error(`Tool '${toolName}' already exists.`);
+    process.exit(1);
+  }
+
+  mkdirSync(toolsDir, { recursive: true });
+
+  const className = toPascalCase(toolName) + "Tool";
+
+  const content = `import { defineTool } from "@johpaz/hive-sdk";
+
+export const ${toolName} = defineTool({
+  name: "${toolName}",
+  description: "Description of what ${toolName} does.",
+  execute: async (args: { input: string }) => {
+    // TODO: implement tool logic
+    return { result: args.input };
+  },
+});
+`;
+
+  writeFileSync(filePath, content);
+  console.log(`✅ Created tool: ${filePath}`);
+}
+
+runAddTool();

package/packages/cli/src/commands/add-worker.ts

@@ -0,0 +1,49 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+
+function toPascalCase(str: string): string {
+  return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase()).replace(/^(.)/, (_, char) => char.toUpperCase());
+}
+
+async function runAddWorker() {
+  const workerName = process.argv[3];
+
+  if (!workerName) {
+    console.error("Usage: hive add-worker <name>");
+    process.exit(1);
+  }
+
+  const workersDir = join(process.cwd(), "src", "workers");
+  const filePath = join(workersDir, `${workerName}.worker.ts`);
+
+  if (existsSync(filePath)) {
+    console.error(`Worker '${workerName}' already exists.`);
+    process.exit(1);
+  }
+
+  mkdirSync(workersDir, { recursive: true });
+
+  const className = toPascalCase(workerName) + "Worker";
+
+  const content = `import { createWorker } from "@johpaz/hive-sdk";
+
+export const ${workerName}Worker = createWorker({
+  name: "${workerName}",
+  systemPrompt: \`
+    You are the ${className} specialist.
+    You handle tasks related to ${workerName} with precision and expertise.
+    Always provide clear, actionable results.
+  \`,
+});
+
+// Example usage:
+// const result = await ${workerName}Worker.run("Your task here");
+// console.log(result);
+`;
+
+  writeFileSync(filePath, content);
+  console.log(`Created worker: ${filePath}`);
+}
+
+runAddWorker();

package/packages/cli/src/commands/create-app-utils.ts

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+const TEMPLATE_DIR = join(import.meta.dir, "..", "..", "templates", "hive-app");
+
+export function copyTemplate(dest: string, replacements: Record<string, string>) {
+  if (!existsSync(TEMPLATE_DIR)) {
+    throw new Error("Template not found: " + TEMPLATE_DIR);
+  }
+
+  copyDir(TEMPLATE_DIR, dest, replacements);
+}
+
+function copyDir(src: string, dest: string, replacements: Record<string, string>) {
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyDir(srcPath, destPath, replacements);
+    } else {
+      let content = readFileSync(srcPath, "utf-8");
+      for (const [key, value] of Object.entries(replacements)) {
+        content = content.replaceAll(key, value);
+      }
+      mkdirSync(dirname(destPath), { recursive: true });
+      writeFileSync(destPath, content);
+    }
+  }
+}

package/packages/cli/src/commands/create-app.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { existsSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+
+const TEST_DIR = join(process.cwd(), "test-create-app-output");
+
+describe("hive create-app", () => {
+  beforeEach(() => {
+    // Clean up before each test
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    // Clean up after each test
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  it("generates a hive-app template with correct structure", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "my-test-app" });
+
+    // Check all expected files exist
+    expect(existsSync(join(TEST_DIR, "package.json"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "hive.config.ts"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "docker-compose.yml"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, ".env.example"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, ".gitignore"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "src", "main.ts"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "src", "agents", "coordinator.ts"))).toBe(true);
+  });
+
+  it("replaces {{APP_NAME}} placeholder in all files", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "my-awesome-app" });
+
+    const packageJson = readFileSync(join(TEST_DIR, "package.json"), "utf-8");
+    expect(packageJson).toContain('"name": "my-awesome-app"');
+
+    const config = readFileSync(join(TEST_DIR, "hive.config.ts"), "utf-8");
+    expect(config).toContain('name: "my-awesome-app"');
+
+    const main = readFileSync(join(TEST_DIR, "src", "main.ts"), "utf-8");
+    expect(main).toContain("Starting my-awesome-app...");
+    expect(main).toContain("my-awesome-app is running at");
+  });
+
+  it("generates valid package.json", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "test-app" });
+
+    const packageJson = JSON.parse(readFileSync(join(TEST_DIR, "package.json"), "utf-8"));
+
+    expect(packageJson.name).toBe("test-app");
+    expect(packageJson.version).toBe("0.1.0");
+    expect(packageJson.type).toBe("module");
+    expect(packageJson.scripts.dev).toBe("bun run src/main.ts");
+    expect(packageJson.scripts.build).toBeDefined();
+    expect(packageJson.dependencies["@johpaz/hive-sdk"]).toBe("latest");
+  });
+
+  it("generates hive.config.ts with correct defaults", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "config-test" });
+
+    const config = readFileSync(join(TEST_DIR, "hive.config.ts"), "utf-8");
+
+    expect(config).toContain('host: process.env.HIVE_HOST ?? "127.0.0.1"');
+    expect(config).toContain('port: Number(process.env.HIVE_PORT ?? 18790)');
+    expect(config).toContain("webchat: { enabled: true }");
+    expect(config).toContain("telegram: { enabled: false }");
+    expect(config).toContain("discord: { enabled: false }");
+    expect(config).toContain("whatsapp: { enabled: false }");
+    expect(config).toContain("slack: { enabled: false }");
+    expect(config).toContain('path: process.env.HIVE_DATA_DIR ?? "./data/hive.db"');
+  });
+
+  it("generates main.ts with all required imports", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "main-test" });
+
+    const main = readFileSync(join(TEST_DIR, "src", "main.ts"), "utf-8");
+
+    expect(main).toContain('from "@johpaz/hive-sdk"');
+    expect(main).toContain("createAgent");
+    expect(main).toContain("startGateway");
+    expect(main).toContain("initializeDatabase");
+    expect(main).toContain("ChannelManager");
+    expect(main).toContain("logger");
+    expect(main).toContain('import config from "../hive.config.ts"');
+    expect(main).toContain("await initializeDatabase()");
+    expect(main).toContain('await startGateway({');
+    expect(main).toContain('process.on("SIGINT"');
+  });
+
+  it("generates coordinator agent with correct config", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "agent-test" });
+
+    const agent = readFileSync(join(TEST_DIR, "src", "agents", "coordinator.ts"), "utf-8");
+
+    expect(agent).toContain('import { createAgent } from "@johpaz/hive-sdk"');
+    expect(agent).toContain('name: "coordinator"');
+    expect(agent).toContain('provider: "openai"');
+    expect(agent).toContain('model: "gpt-4o-mini"');
+  });
+
+  it("generates docker-compose.yml with correct ports", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "docker-test" });
+
+    const docker = readFileSync(join(TEST_DIR, "docker-compose.yml"), "utf-8");
+
+    expect(docker).toContain('image: oven/bun:latest');
+    expect(docker).toContain('"${HIVE_PORT:-18790}:18790"');
+    expect(docker).toContain('HIVE_HOST=0.0.0.0');
+    expect(docker).toContain('HIVE_PORT=18790');
+    expect(docker).toContain('command: ["bun", "run", "src/main.ts"]');
+    expect(docker).toContain('restart: unless-stopped');
+  });
+
+  it("generates .env.example with all required variables", async () => {
+    const { copyTemplate } = await import("./create-app-utils.ts");
+
+    copyTemplate(TEST_DIR, { "{{APP_NAME}}": "env-test" });
+
+    const env = readFileSync(join(TEST_DIR, ".env.example"), "utf-8");
+
+    expect(env).toContain("HIVE_HOST=");
+    expect(env).toContain("HIVE_PORT=");
+    expect(env).toContain("HIVE_DATA_DIR=");
+    expect(env).toContain("OPENAI_API_KEY=");
+    expect(env).toContain("ANTHROPIC_API_KEY=");
+    expect(env).toContain("GOOGLE_API_KEY=");
+    expect(env).toContain("TELEGRAM_BOT_TOKEN=");
+    expect(env).toContain("DISCORD_BOT_TOKEN=");
+    expect(env).toContain("SLACK_BOT_TOKEN=");
+    expect(env).toContain("LOG_LEVEL=");
+  });
+});

package/packages/cli/src/commands/create-app.ts

@@ -0,0 +1,35 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+import { copyTemplate } from "./create-app-utils.ts";
+
+async function runCreateApp() {
+  const appName = process.argv[3];
+
+  if (!appName) {
+    console.error("Usage: hive create-app <name>");
+    process.exit(1);
+  }
+
+  const targetDir = join(process.cwd(), appName);
+
+  if (existsSync(targetDir)) {
+    console.error(`Directory '${appName}' already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`Creating Hive app '${appName}'...`);
+
+  copyTemplate(targetDir, {
+    "{{APP_NAME}}": appName,
+  });
+
+  console.log(`\n✅ Created ${appName} in ${targetDir}`);
+  console.log("\nNext steps:");
+  console.log(`  cd ${appName}`);
+  console.log("  bun install");
+  console.log("  cp .env.example .env");
+  console.log("  bun run dev");
+}
+
+runCreateApp();

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

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as process from "node:process";
+
+const TEMPLATE_DIR = join(import.meta.dir, "..", "..", "templates");
+
+const HIVE_CONFIG = `{
+  "name": "my-hive-agent",
+  "version": "0.1.0",
+  "type": "module",
+  "dependencies": {
+    "@hive/core": "latest"
+  }
+}
+`;
+
+const HIVE_AGENT_TS = `import { createAgent, defineTool } from "@hive/core";
+
+const myTool = defineTool({
+  name: "hello",
+  description: "Say hello",
+  execute: async (args: { name?: string }) => {
+    return { greeting: \`Hello, \${args.name ?? "world"}!\` };
+  },
+});
+
+const agent = await createAgent({
+  name: "my-agent",
+  model: "gpt-4o",
+  provider: "openai",
+  tools: [myTool],
+});
+
+console.log("Agent ready:", agent.name);
+`;
+
+async function runInit() {
+	const targetDir = process.argv[3] || process.cwd();
+
+	if (existsSync(join(targetDir, "hive.json"))) {
+		console.error("A hive project already exists in this directory.");
+		process.exit(1);
+	}
+
+	writeFileSync(join(targetDir, "hive.json"), HIVE_CONFIG.trim());
+	writeFileSync(join(targetDir, "hive.agent.ts"), HIVE_AGENT_TS.trim());
+
+	console.log(`\nInitialized Hive project in ${targetDir}`);
+	console.log("\nFiles created:");
+	console.log("  hive.json       - Project configuration");
+	console.log("  hive.agent.ts   - Agent definition");
+	console.log("\nNext steps:");
+	console.log("  Run: hive run");
+}
+
+runInit();

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

@@ -0,0 +1,45 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+async function runCommand() {
+	const agentFile = findAgentFile();
+	if (!agentFile) {
+		console.error("No hive.agent.ts or hive.agent.js found in current directory.");
+		console.error("Run 'hive init' to create one.");
+		process.exit(1);
+	}
+
+	console.log(`Running agent from ${agentFile}...`);
+	const { createAgent } = await import("@hive/core");
+	const agentModule = await import(agentFile);
+
+	if (agentModule.agent) {
+		const input = process.argv[3] || process.env.HIVE_INPUT || "Hello!";
+		console.log(`\n--- Agent: ${agentModule.agent.name} ---`);
+		console.log(`Input: ${input}\n`);
+
+		for await (const event of agentModule.agent.chat(input)) {
+			if (event.type === "text") {
+				process.stdout.write(event.content);
+			} else if (event.type === "tool_call") {
+				console.log(`\n[Tool: ${event.name}]`);
+			}
+		}
+		console.log("\n--- Done ---");
+	} else {
+		console.error("Agent module does not export an 'agent' instance.");
+		process.exit(1);
+	}
+}
+
+function findAgentFile(): string | null {
+	const candidates = ["hive.agent.ts", "hive.agent.js", "agent.ts", "agent.js"];
+	const cwd = process.cwd();
+	for (const name of candidates) {
+		const full = join(cwd, name);
+		if (existsSync(full)) return full;
+	}
+	return null;
+}
+
+runCommand();