@johpaz/hive-sdk 0.0.14 → 0.0.16

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

@@ -0,0 +1,42 @@
+export {};
+async function testCommand() {
+	const filter = process.argv[3];
+
+	console.log("Hive Test Runner\n");
+
+	const { initializeDatabase, dbService } = await import("@hive/core");
+	await initializeDatabase();
+
+	const { Glob } = await import("bun");
+	const glob = new Glob("packages/core/src/**/*.{test,spec}.ts");
+	const testFiles = Array.from(glob.scanSync({ cwd: process.cwd(), absolute: true }));
+
+	const tests = filter
+		? testFiles.filter((f: string) => f.includes(filter))
+		: testFiles;
+
+	if (tests.length === 0) {
+		console.log("No tests found.");
+	} else {
+		console.log(`Found ${tests.length} test(s)\n`);
+		let passed = 0;
+		let failed = 0;
+
+		for (const test of tests as string[]) {
+			try {
+				await import(test);
+				console.log(`  ✓ ${test.split("/").pop()}`);
+				passed++;
+			} catch (err) {
+				console.error(`  ✗ ${test.split("/").pop()}: ${(err as Error).message}`);
+				failed++;
+			}
+		}
+
+		console.log(`\n${passed} passed, ${failed} failed`);
+	}
+
+	dbService.close();
+}
+
+testCommand();

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

@@ -0,0 +1,55 @@
+export {};
+async function traceCommand() {
+	const { initializeDatabase } = await import("@hive/core");
+	const { getDb } = await import("@hive/core/storage");
+
+	await initializeDatabase();
+	const db = getDb();
+
+	const limit = parseInt(process.argv[3] || "20", 10);
+
+	console.log(`\nRecent Trace Logs (last ${limit})\n`);
+	console.log("─".repeat(80));
+
+	try {
+		const rows = db
+			.query(
+				`SELECT id, agent_id, model, tool_calls, duration_ms, tokens_used, created_at
+         FROM traces
+         ORDER BY created_at DESC
+         LIMIT ?`
+			)
+			.all(limit) as Array<{
+			id: string;
+			agent_id: string;
+			model: string;
+			tool_calls: string;
+			duration_ms: number;
+			tokens_used: number;
+			created_at: string;
+		}>;
+
+		if (rows.length === 0) {
+			console.log("No traces found.");
+			return;
+		}
+
+		for (const row of rows) {
+			console.log(`ID:        ${row.id}`);
+			console.log(`Agent:     ${row.agent_id}`);
+			console.log(`Model:     ${row.model}`);
+			console.log(`Duration:  ${row.duration_ms}ms`);
+			console.log(`Tokens:    ${row.tokens_used}`);
+			console.log(`Time:      ${row.created_at}`);
+			if (row.tool_calls) {
+				const tools = JSON.parse(row.tool_calls);
+				console.log(`Tools:     ${Array.isArray(tools) ? tools.join(", ") : row.tool_calls}`);
+			}
+			console.log("─".repeat(80));
+		}
+	} catch (err) {
+		console.log("No traces table found (run the agent first).");
+	}
+}
+
+traceCommand();

package/packages/cli/src/index.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env bun
+
+export {};
+const command = process.argv[2];
+
+switch (command) {
+	case "init":
+		await import("./commands/init.ts");
+		break;
+	case "create-app":
+		await import("./commands/create-app.ts");
+		break;
+	case "add-tool":
+		await import("./commands/add-tool.ts");
+		break;
+	case "add-skill":
+		await import("./commands/add-skill.ts");
+		break;
+	case "add-worker":
+		await import("./commands/add-worker.ts");
+		break;
+	case "run":
+		await import("./commands/run.ts");
+		break;
+	case "test":
+		await import("./commands/test.ts");
+		break;
+	case "trace":
+		await import("./commands/trace.ts");
+		break;
+	case "--help":
+	case "-h":
+	case undefined:
+		printHelp();
+		break;
+	default:
+		console.error(`Unknown command: ${command}`);
+		printHelp();
+		process.exit(1);
+}
+
+function printHelp() {
+	console.log(`
+Usage: hive <command> [options]
+
+Commands:
+  init <name>         Initialize a new Hive agent project
+  create-app <name>   Create a full Hive harness application
+  add-tool <name>     Add a new tool to the current project
+  add-skill <name>    Add a new skill to the current project
+  add-worker <name>   Add a new Bun Worker to the current project
+  run                 Run the agent
+  test                Test tools or skills
+  trace               View trace execution logs
+
+Options:
+  --help, -h          Show this help message
+`);
+}

package/packages/cli/templates/hive-app/.env.example

@@ -0,0 +1,17 @@
+# Hive Harness Configuration
+HIVE_HOST=127.0.0.1
+HIVE_PORT=18790
+HIVE_DATA_DIR=./data
+
+# LLM Providers
+OPENAI_API_KEY=sk-...
+ANTHROPIC_API_KEY=sk-ant-...
+GOOGLE_API_KEY=...
+
+# Channels (enable as needed)
+TELEGRAM_BOT_TOKEN=
+DISCORD_BOT_TOKEN=
+SLACK_BOT_TOKEN=
+
+# Logging
+LOG_LEVEL=info

package/packages/cli/templates/hive-app/docker-compose.yml

@@ -0,0 +1,20 @@
+services:
+  app:
+    image: oven/bun:latest
+    working_dir: /app
+    volumes:
+      - .:/app
+      - hive-data:/app/data
+    ports:
+      - "${HIVE_PORT:-18790}:18790"
+    environment:
+      - HIVE_HOST=0.0.0.0
+      - HIVE_PORT=18790
+      - HIVE_DATA_DIR=/app/data
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+    command: ["bun", "run", "src/main.ts"]
+    restart: unless-stopped
+
+volumes:
+  hive-data:

package/packages/cli/templates/hive-app/hive.config.ts

@@ -0,0 +1,19 @@
+import type { Config } from "@johpaz/hive-sdk";
+
+export default {
+  name: "{{APP_NAME}}",
+  gateway: {
+    host: process.env.HIVE_HOST ?? "127.0.0.1",
+    port: Number(process.env.HIVE_PORT ?? 18790),
+  },
+  channels: {
+    webchat: { enabled: true },
+    telegram: { enabled: false },
+    discord: { enabled: false },
+    whatsapp: { enabled: false },
+    slack: { enabled: false },
+  },
+  database: {
+    path: process.env.HIVE_DATA_DIR ?? "./data/hive.db",
+  },
+} satisfies Config;

package/packages/cli/templates/hive-app/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "{{APP_NAME}}",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "bun run src/main.ts",
+    "start": "bun run src/main.ts",
+    "build": "bun build src/main.ts --outdir dist --target bun"
+  },
+  "dependencies": {
+    "@johpaz/hive-sdk": "latest"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/packages/cli/templates/hive-app/src/agents/coordinator.ts

@@ -0,0 +1,9 @@
+import { createAgent } from "@johpaz/hive-sdk";
+
+export const coordinatorAgent = await createAgent({
+  name: "coordinator",
+  provider: "openai",
+  model: "gpt-4o-mini",
+  systemPrompt:
+    "You are the coordinator agent. You orchestrate tasks, answer questions, and delegate to specialized agents when needed.",
+});

package/packages/cli/templates/hive-app/src/main.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+
+import {
+  createAgent,
+  startGateway,
+  initializeDatabase,
+  ChannelManager,
+  logger,
+  loadConfig,
+} from "@johpaz/hive-sdk";
+import config from "../hive.config.ts";
+
+const log = logger.child("app");
+
+async function main() {
+  log.info(`Starting {{APP_NAME}}...`);
+
+  // Initialize database
+  await initializeDatabase();
+
+  // Create the main agent
+  const agent = await createAgent({
+    name: "coordinator",
+    provider: "openai",
+    model: "gpt-4o-mini",
+    systemPrompt:
+      "You are a helpful AI assistant running in a Hive harness. You can use tools, manage tasks, and communicate across channels.",
+  });
+
+  log.info(`Agent ready: ${agent.name}`);
+
+  // Initialize channels
+  const channelManager = new ChannelManager();
+  // TODO: configure channels from hive.config.ts
+
+  // Start the gateway
+  const gateway = await startGateway({
+    host: config.gateway?.host,
+    port: config.gateway?.port,
+    agentId: "coordinator",
+  });
+
+  log.info(`{{APP_NAME}} is running at http://${gateway.hostname}:${gateway.port}`);
+
+  // Graceful shutdown
+  process.on("SIGINT", async () => {
+    log.info("Shutting down...");
+    gateway.stop(true);
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  log.error("Fatal error:", err);
+  process.exit(1);
+});

package/packages/core/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@hive/core",
+  "version": "0.0.15",
+  "description": "Hive Core — Agentes AI con Context Engineering, FTS5, ACE, Swarm",
+  "license": "MIT",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./agent": "./src/agent/index.ts",
+    "./agent/providers": "./src/agent/providers/index.ts",
+    "./agent/selectors": "./src/agent/selectors/index.ts",
+    "./tools": "./src/tools/index.ts",
+    "./skills": "./src/skills/index.ts",
+    "./storage": "./src/storage/index.ts",
+    "./swarm": "./src/swarm/index.ts",
+    "./swarm/strategies": "./src/swarm/strategies/index.ts",
+    "./swarm/presets": "./src/swarm/presets/index.ts",
+    "./ace": "./src/ace/index.ts",
+    "./ethics": "./src/ethics/index.ts",
+    "./canvas": "./src/canvas/index.ts",
+    "./config": "./src/config/index.ts",
+    "./mcp": "./src/mcp/index.ts",
+    "./mcp/transports": "./src/mcp/transports/index.ts",
+    "./memory": "./src/memory/index.ts",
+    "./multimodal": "./src/multimodal/index.ts",
+    "./security": "./src/security/index.ts",
+    "./state": "./src/state/index.ts",
+    "./utils": "./src/utils/index.ts",
+    "./gateway": "./src/gateway/index.ts",
+    "./api": "./src/api/index.ts"
+  },
+  "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"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/packages/core/src/ace/Curator.ts

@@ -0,0 +1,158 @@
+/**
+ * ACE Curator — converts reflections into playbook rules.
+ *
+ * Runs after the Reflector. Performs incremental edits to the playbook:
+ *   - New insights → new rules
+ *   - Repeated patterns → increment helpful_count
+ *   - Contradicted rules → increment harmful_count or deactivate
+ *   - Deactivate rules where harmful_count > helpful_count
+ *   - Archive unused workers
+ *
+ * Never rewrites the whole playbook — only incremental edits.
+ */
+
+import { logger } from "../utils/logger.ts"
+
+const log = logger.child("curator")
+
+const DAYS_BEFORE_ARCHIVE = 14   // archive workers not used in N days
+const MAX_HARMFUL_BEFORE_PRUNE = 3
+
+/** Entry point — called by reflector.ts after it inserts new reflections */
+export async function runCurator(): Promise<void> {
+  try {
+    const { getDb } = await import("../storage/SQLiteStorage.ts")
+    const db = getDb()
+
+    // Process unprocessed reflections (those newer than last run)
+    const lastProcessed = (db.query<any, []>(
+      "SELECT COALESCE(MAX(source_reflection_id), 0) as mid FROM playbook"
+    ).get() as any)?.mid ?? 0
+
+    const reflections = (db.query as any)(
+      "SELECT * FROM reflections WHERE id > ? ORDER BY id ASC"
+    ).all(lastProcessed)
+
+    if (reflections.length === 0) {
+      log.debug("[curator] No new reflections to process")
+    } else {
+      log.info(`[curator] Processing ${reflections.length} new reflections`)
+      for (const reflection of reflections) {
+        processReflection(db, reflection)
+      }
+    }
+
+    // Prune rules where harmful > helpful (consistently bad rules)
+    db.query(`
+      UPDATE playbook
+      SET active = 0, updated_at = unixepoch()
+      WHERE active = 1
+        AND harmful_count > helpful_count
+        AND harmful_count >= ?
+    `).run(MAX_HARMFUL_BEFORE_PRUNE)
+
+    // Archive unused workers
+    const cutoff = Math.floor(Date.now() / 1000) - (DAYS_BEFORE_ARCHIVE * 86400)
+    const staleworkers = (db.query as any)(`
+      SELECT a.id, a.name
+      FROM agents a
+      WHERE a.role = 'worker'
+        AND a.status != 'archived'
+        AND a.enabled = 1
+        AND (
+          SELECT MAX(t.created_at) FROM traces t WHERE t.agent_id = a.id
+        ) < ?
+    `).all(cutoff)
+
+    for (const worker of staleworkers) {
+      db.query(
+        "UPDATE agents SET status = 'archived', updated_at = unixepoch() WHERE id = ?"
+      ).run(worker.id)
+
+      // Add playbook note about archival
+      addOrUpdateRule(db, {
+        rule: `Worker '${worker.name}' was archived due to inactivity (>${DAYS_BEFORE_ARCHIVE} days unused).`,
+        category: "agent_creation",
+        applicable_to: null,
+        sourceReflectionId: null,
+      })
+
+      log.info(`[curator] Archived inactive worker: ${worker.name} (${worker.id})`)
+    }
+
+    log.info("[curator] Playbook updated")
+  } catch (err) {
+    log.warn("[curator] Error:", err)
+  }
+}
+
+// ─── Process a single reflection ─────────────────────────────────────────────
+
+function processReflection(db: any, reflection: any): void {
+  const category = mapInsightTypeToCategory(reflection.insight_type)
+
+  // Check if a similar rule already exists (fuzzy check by first 60 chars)
+  const prefix = reflection.description.substring(0, 60)
+  const existing = (db.query as any)(
+    "SELECT id, helpful_count FROM playbook WHERE rule LIKE ? AND active = 1 LIMIT 1"
+  ).get(`${prefix}%`)
+
+  if (existing) {
+    // Reinforce existing rule
+    db.query(
+      "UPDATE playbook SET helpful_count = helpful_count + 1, updated_at = unixepoch() WHERE id = ?"
+    ).run(existing.id)
+    return
+  }
+
+  // Insert new rule
+  db.query(`
+    INSERT INTO playbook (rule, category, applicable_to, helpful_count, source_reflection_id)
+    VALUES (?, ?, ?, 1, ?)
+  `).run(
+    reflection.description,
+    category,
+    reflection.affected_tools
+      ? JSON.stringify(JSON.parse(reflection.affected_tools))
+      : null,
+    reflection.id,
+  )
+}
+
+function mapInsightTypeToCategory(
+  type: string
+): "tool_selection" | "response_quality" | "error_avoidance" | "optimization" | "agent_creation" {
+  const map: Record<string, any> = {
+    success_pattern: "tool_selection",
+    failure_pattern: "error_avoidance",
+    optimization: "optimization",
+    ethics_violation: "error_avoidance",
+  }
+  return map[type] ?? "optimization"
+}
+
+function addOrUpdateRule(
+  db: any,
+  opts: {
+    rule: string
+    category: string
+    applicable_to: string | null
+    sourceReflectionId: number | null
+  }
+): void {
+  const prefix = opts.rule.substring(0, 60)
+  const existing = (db.query as any)(
+    "SELECT id FROM playbook WHERE rule LIKE ? LIMIT 1"
+  ).get(`${prefix}%`)
+
+  if (existing) {
+    db.query(
+      "UPDATE playbook SET helpful_count = helpful_count + 1, updated_at = unixepoch() WHERE id = ?"
+    ).run(existing.id)
+  } else {
+    db.query(`
+      INSERT INTO playbook (rule, category, applicable_to, helpful_count, source_reflection_id)
+      VALUES (?, ?, ?, 1, ?)
+    `).run(opts.rule, opts.category, opts.applicable_to, opts.sourceReflectionId)
+  }
+}