@johpaz/hive-sdk 0.0.17 → 0.1.3

package/packages/core/src/memory/Scratchpad.ts

@@ -1,37 +1,54 @@
-import type { Database } from "bun:sqlite";
+import { getHiveDB } from "../storage/HiveDBStorage.ts";
+
+interface ScratchpadDoc {
+  threadId: string;
+  key: string;
+  value: string;
+  updatedAt: number;
+}
 
 export class Scratchpad {
-  constructor(private db: Database) {}
+  async write(threadId: string, key: string, value: string): Promise<void> {
+    const db = await getHiveDB();
+    const col = db.collection<ScratchpadDoc>("scratchpad");
+    await col.put(this.docId(threadId, key), { threadId, key, value, updatedAt: Date.now() });
+  }
 
-  write(threadId: string, key: string, value: string): void {
-    this.db.run(
-      `INSERT OR REPLACE INTO scratchpad (thread_id, key, value, updated_at) VALUES (?, ?, ?, datetime('now'))`,
-      [threadId, key, value]
-    );
+  async read(threadId: string, key: string): Promise<string | undefined> {
+    const db = await getHiveDB();
+    const col = db.collection<ScratchpadDoc>("scratchpad");
+    const entry = await col.get(this.docId(threadId, key));
+    return entry?.doc.value;
   }
 
-  read(threadId: string, key: string): string | null {
-    const row = this.db
-      .query(`SELECT value FROM scratchpad WHERE thread_id = ? AND key = ?`)
-      .get(threadId, key) as any;
-    return row?.value ?? null;
+  async list(threadId: string): Promise<Record<string, string>> {
+    const db = await getHiveDB();
+    const col = db.collection<ScratchpadDoc>("scratchpad");
+    const entries = await col.scan();
+    const result: Record<string, string> = {};
+    for (const e of entries) {
+      if (e.doc.threadId === threadId) {
+        result[e.doc.key] = e.doc.value;
+      }
+    }
+    return result;
   }
 
-  list(threadId: string): Record<string, string> {
-    const rows = this.db
-      .query(`SELECT key, value FROM scratchpad WHERE thread_id = ?`)
-      .all(threadId) as any[];
-    return Object.fromEntries(rows.map(r => [r.key, r.value]));
+  async delete(threadId: string, key: string): Promise<void> {
+    const db = await getHiveDB();
+    const col = db.collection<ScratchpadDoc>("scratchpad");
+    await col.delete(this.docId(threadId, key));
   }
 
-  delete(threadId: string, key: string): void {
-    this.db.run(
-      `DELETE FROM scratchpad WHERE thread_id = ? AND key = ?`,
-      [threadId, key]
-    );
+  async clear(threadId: string): Promise<void> {
+    const db = await getHiveDB();
+    const col = db.collection<ScratchpadDoc>("scratchpad");
+    const entries = await col.scan();
+    const ids = entries.filter(e => e.doc.threadId === threadId).map(e => e.id);
+    await db.batch(ids.map(id => ({ op: "delete" as const, collection: "scratchpad", id })));
   }
 
-  clear(threadId: string): void {
-    this.db.run(`DELETE FROM scratchpad WHERE thread_id = ?`, [threadId]);
+  private docId(threadId: string, key: string): string {
+    return `${threadId}:${key}`;
   }
 }

package/packages/core/src/skills/bundled-data.generated.ts

@@ -338,6 +338,56 @@ Esta skill se activa para automatizar flujos de interacción con aplicaciones we
 - ❌ No esperar carga de página
 - ❌ Ignorar errores de elementos
 - ❌ No verificar estado después de acciones
+`,
+  },
+  {
+    name: "web_browser_research",
+    description: `Search the web and navigate results with a real browser to extract content from dynamic or JavaScript-heavy sites`,
+    category: "web",
+    version: "1.0.0",
+    tools: ["web_search","browser_navigate","browser_extract","web_fetch"],
+    triggers: ["investigá en web con navegador","web browser research","buscá y navegá","search and browse","research with browser","navegá los resultados","browse search results","contenido dinámico","dynamic content research","sitios con javascript","javascript sites research"],
+    body: `
+# Web Browser Research Skill
+
+## Cuándo se Activa
+
+Esta skill se activa cuando el usuario necesita investigación web profunda, especialmente cuando:
+- Los resultados de búsqueda pueden requerir navegación real por sitios dinámicos.
+- El contenido objetivo está renderizado con JavaScript (SPAs, dashboards, etc.).
+- Se necesita extraer datos estructurados de páginas web.
+
+## Herramientas Disponibles
+
+| Tool | Qué hace | Cuándo usarla |
+|------|----------|---------------|
+| \`web_search\` | Busca en internet y devuelve resultados | Encontrar URLs relevantes |
+| \`browser_navigate\` | Navega y renderiza la página completa | Sitios dinámicos con JavaScript |
+| \`browser_extract\` | Extrae datos con selectores CSS/XPath | Obtener contenido estructurado |
+| \`web_fetch\` | Descarga contenido estático | Páginas simples o respaldo |
+
+## Workflow
+
+1. **Buscar** → \`web_search({ query, numResults: 5 })\`
+2. **Seleccionar fuentes** → Elegir 2-3 URLs relevantes y confiables.
+3. **Navegar** → \`browser_navigate({ url })\` para cada fuente dinámica.
+4. **Extraer** → \`browser_extract({ selector: "article, .content, main" })\` o similar.
+5. **Respaldo estático** → Si el browser falla, usar \`web_fetch({ url })\`.
+6. **Sintetizar** → Responder con puntos clave y citas con URLs completas.
+
+## Mejores Prácticas
+
+- Priorizar sitios oficiales, documentación y fuentes primarias.
+- Usar selectores estables (etiquetas semánticas como \`article\`, \`main\`).
+- Si el contenido es largo, extraer por secciones.
+- Siempre incluir URLs de fuentes en la respuesta final.
+
+## Errores a Evitar
+
+- ❌ Usar solo \`web_fetch\` para SPAs sin probar el browser primero.
+- ❌ Seleccionar selectores frágiles basados en clases aleatorias.
+- ❌ No citar las fuentes usadas.
+- ❌ Confundir snippets de búsqueda con contenido completo verificado.
 `,
   },
   {

package/packages/core/src/skills/skills.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "bun:test";
+import { BUNDLED_SKILLS_DATA } from "./bundled-data.generated.ts";
+
+describe("Bundled skills", () => {
+  it("includes web_browser_research skill", () => {
+    const skill = BUNDLED_SKILLS_DATA.find((s) => s.name === "web_browser_research");
+    expect(skill).toBeDefined();
+    expect(skill?.category).toBe("web");
+    expect(skill?.tools).toContain("web_search");
+    expect(skill?.tools).toContain("browser_navigate");
+    expect(skill?.tools).toContain("browser_extract");
+    expect(skill?.triggers.length).toBeGreaterThan(0);
+  });
+
+  it("includes existing web and browser skills", () => {
+    const names = BUNDLED_SKILLS_DATA.map((s) => s.name);
+    expect(names).toContain("web_research");
+    expect(names).toContain("browser_scrape");
+    expect(names).toContain("browser_automate");
+  });
+});

package/packages/core/src/storage/HiveDBStorage.ts

@@ -0,0 +1,64 @@
+import { HiveDB, type Collection, type EventInput, type Event } from "@johpaz/hive-db";
+import * as path from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { getHiveDir } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+const log = logger.child("hivedb-storage");
+
+let _db: HiveDB | null = null;
+let _opening: Promise<HiveDB> | null = null;
+
+export function getHiveDbPath(): string {
+  return path.join(getHiveDir(), "data", "hive");
+}
+
+export function openHiveDB(): Promise<HiveDB> {
+  if (_db) return Promise.resolve(_db);
+  if (_opening) return _opening;
+
+  const hiveDir = getHiveDir();
+  const dir = path.join(hiveDir, "data");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const dbPath = getHiveDbPath();
+  log.info(`[hivedb] Opening HiveDB at ${dbPath}`);
+  _opening = HiveDB.open(dbPath, { vector: { dimension: 384, spaceId: "hive-sdk-v1" } }).then((db) => {
+    _db = db;
+    _opening = null;
+    return db;
+  });
+  return _opening;
+}
+
+export async function getHiveDB(): Promise<HiveDB> {
+  if (_db) return _db;
+  if (_opening) return _opening;
+  return openHiveDB();
+}
+
+export async function closeHiveDB(): Promise<void> {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+  _opening = null;
+}
+
+export async function hiveCollection<T = unknown>(name: string): Promise<Collection<T>> {
+  return (await getHiveDB()).collection<T>(name);
+}
+
+export async function hiveAppend(input: EventInput): Promise<number> {
+  return (await getHiveDB()).append(input);
+}
+
+export async function hiveRead(seq: number): Promise<Event> {
+  return (await getHiveDB()).read(seq);
+}
+
+export function isHiveDBInitialized(): boolean {
+  return _db !== null;
+}

package/packages/core/src/storage/SQLiteStorage.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { getHiveDir } from "../config/loader.ts";
 import { SCHEMA, PROJECTS_SCHEMA, CONTEXT_ENGINE_SCHEMA, MEETING_SCHEMA } from "./schema.ts";
+import { openHiveDB, closeHiveDB } from "./HiveDBStorage.ts";
 
 function getDbPath(): string {
     return path.join(getHiveDir(), "data", "hive.db");
@@ -84,6 +85,12 @@ export function initializeDatabase(): Database {
 
     ensureSchemaSync();
 
+    // Open HiveDB as the new source-of-truth engine alongside SQLite
+    // during the migration; SQLite will be removed once all tables are migrated.
+    openHiveDB().catch((err) => {
+      logger.error("❌ Failed to initialize HiveDB:", err);
+    });
+
     return _db;
 }
 

package/packages/core/src/storage/hiveSeed.ts

@@ -0,0 +1,308 @@
+import { getHiveDB, hiveCollection } from "./HiveDBStorage.ts";
+import { logger } from "../utils/logger.ts";
+import { SEED_DATA, INITIAL_PLAYBOOK_RULES } from "./seed.ts";
+import { SkillLoader } from "../skills/index.ts";
+import { enrichToolDescription } from "../agent/selectors/ToolSelector.ts";
+import type { ToolDescriptor } from "../agent/selectors/ToolSelector.ts";
+import type { IndexDoc, HiveDB } from "@johpaz/hive-db";
+
+const log = logger.child("hive-seed");
+
+export interface HiveToolDoc {
+  name: string;
+  description: string;
+  category: string;
+  enabled: boolean;
+  active: boolean;
+}
+
+export interface HiveProviderDoc {
+  id: string;
+  name: string;
+  baseUrl?: string;
+  category: string;
+  enabled: boolean;
+  active: boolean;
+}
+
+export interface HiveModelDoc {
+  id: string;
+  providerId: string;
+  name: string;
+  modelType: string;
+  contextWindow?: number;
+  capabilities?: string[];
+  enabled: boolean;
+  active: boolean;
+}
+
+export interface HiveSkillDoc {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  author: string;
+  icon: string;
+  category: string;
+  permissions: string[];
+  dependencies: string[];
+  tools: string[];
+  triggers: string[];
+  preferredAgents: string[];
+  body: string;
+  versionNum: number;
+  active: boolean;
+}
+
+export interface HiveAgentDoc {
+  id: string;
+  userId?: string;
+  name: string;
+  description: string;
+  systemPrompt: string;
+  toolsJson?: string;
+  role: string;
+  status: string;
+  parentId?: string;
+  providerId: string;
+  modelId: string;
+  tone?: string;
+  maxIterations: number;
+  workspace?: string;
+  enabled: boolean;
+  active: boolean;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface HiveChannelDoc {
+  id: string;
+  type: string;
+  enabled: boolean;
+  active: boolean;
+  status: string;
+}
+
+export interface HiveEthicsDoc {
+  id: string;
+  name: string;
+  description: string;
+  content: string;
+  isDefault: boolean;
+  enabled: boolean;
+  active: boolean;
+}
+
+export interface HiveCodeBridgeDoc {
+  id: string;
+  name: string;
+  cliCommand: string;
+  port: number;
+  enabled: boolean;
+  active: boolean;
+}
+
+export interface HiveCodeBridgeConfigDoc {
+  id: string;
+  key: string;
+  value: string;
+}
+
+export interface HivePlaybookDoc {
+  rule: string;
+  category: string;
+  applicableTo?: string[];
+  helpfulCount: number;
+  harmfulCount: number;
+  active: boolean;
+}
+
+export async function seedHiveDB(db?: HiveDB): Promise<void> {
+  db ??= await getHiveDB();
+
+  log.info("[hive-seed] 🌱 Iniciando seed de HiveDB");
+
+  // 1️⃣ Tools
+  const toolsCol = db.collection<HiveToolDoc>("tools");
+  await toolsCol.createIndex("name", { unique: true });
+  for (const tool of SEED_DATA.tools) {
+    await toolsCol.put(tool.id, {
+      name: tool.name,
+      description: tool.description,
+      category: tool.category,
+      enabled: tool.enabled ?? true,
+      active: true,
+    });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.tools.length} tools seeded`);
+
+  // 2️⃣ Index tools for hybrid search
+  const toolDocs: IndexDoc[] = SEED_DATA.tools.map(tool => ({
+    id: tool.name,
+    name: tool.name,
+    body: enrichToolDescription({ name: tool.name, description: tool.description, category: tool.category } as ToolDescriptor),
+    tags: tool.category,
+    filters: [{ field: "type", value: "tool" }],
+  }));
+  await db.upsertBatch(toolDocs);
+  log.info(`[hive-seed] ✅ ${toolDocs.length} tools indexed`);
+
+  // 3️⃣ Providers
+  const providersCol = db.collection<HiveProviderDoc>("providers");
+  await providersCol.createIndex("id", { unique: true });
+  for (const provider of SEED_DATA.providers) {
+    await providersCol.put(provider.id, {
+      id: provider.id,
+      name: provider.name,
+      baseUrl: provider.baseUrl,
+      category: provider.category ?? "llm",
+      enabled: true,
+      active: false,
+    });
+  }
+  const ollamaHost = process.env.OLLAMA_HOST;
+  if (ollamaHost) {
+    const entry = await providersCol.get("ollama");
+    if (entry) {
+      await providersCol.put("ollama", { ...entry.doc, baseUrl: ollamaHost });
+    }
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.providers.length} providers seeded`);
+
+  // 4️⃣ Models
+  const modelsCol = db.collection<HiveModelDoc>("models");
+  await modelsCol.createIndex("id", { unique: true });
+  await modelsCol.createIndex("providerId");
+  for (const model of SEED_DATA.models) {
+    await modelsCol.put(model.id, {
+      id: model.id,
+      providerId: model.providerId,
+      name: model.name,
+      modelType: model.modelType,
+      contextWindow: model.contextWindow,
+      capabilities: model.capabilities ? JSON.parse(model.capabilities) : undefined,
+      enabled: true,
+      active: false,
+    });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.models.length} models seeded`);
+
+  // 5️⃣ MCP servers
+  const mcpCol = db.collection("mcp_servers");
+  await mcpCol.createIndex("id", { unique: true });
+  for (const mcp of SEED_DATA.mcpServers) {
+    await mcpCol.put(mcp.id, { ...mcp, enabled: true, active: false, builtin: mcp.builtin, toolsCount: 0 });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.mcpServers.length} MCP servers seeded`);
+
+  // 6️⃣ Channels
+  const channelsCol = db.collection<HiveChannelDoc>("channels");
+  await channelsCol.createIndex("id", { unique: true });
+  for (const channel of SEED_DATA.channels) {
+    const isWebChat = channel.id === "webchat";
+    await channelsCol.put(channel.id, {
+      id: channel.id,
+      type: channel.type,
+      enabled: true,
+      active: isWebChat,
+      status: isWebChat ? "connected" : "disconnected",
+    });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.channels.length} channels seeded`);
+
+  // 7️⃣ Ethics
+  const ethicsCol = db.collection<HiveEthicsDoc>("ethics");
+  await ethicsCol.createIndex("id", { unique: true });
+  for (const ethics of SEED_DATA.ethics) {
+    await ethicsCol.put(ethics.id, {
+      id: ethics.id,
+      name: ethics.name,
+      description: ethics.description,
+      content: ethics.content,
+      isDefault: ethics.isDefault,
+      enabled: true,
+      active: ethics.isDefault,
+    });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.ethics.length} ethics templates seeded`);
+
+  // 8️⃣ Code Bridge
+  const cbCol = db.collection<HiveCodeBridgeDoc>("code_bridge");
+  await cbCol.createIndex("id", { unique: true });
+  for (const cb of SEED_DATA.codeBridge) {
+    await cbCol.put(cb.id, { ...cb, enabled: false, active: false });
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.codeBridge.length} Code Bridge entries seeded`);
+
+  // 9️⃣ Code Bridge Config
+  const cbConfigCol = db.collection<HiveCodeBridgeConfigDoc>("code_bridge_config");
+  await cbConfigCol.createIndex("id", { unique: true });
+  for (const config of SEED_DATA.codeBridgeConfig) {
+    await cbConfigCol.put(config.id, config);
+  }
+  log.info(`[hive-seed] ✅ ${SEED_DATA.codeBridgeConfig.length} Code Bridge Config entries seeded`);
+
+  // 🔟 Skills
+  const skillLoader = new SkillLoader({ workspacePath: process.env.HIVE_HOME || process.cwd() });
+  const realSkills = skillLoader.loadBundledSkills();
+  const skillsCol = db.collection("skills");
+  await skillsCol.createIndex("id", { unique: true });
+  const skillDocs: IndexDoc[] = [];
+  for (const s of realSkills) {
+    const doc = {
+      id: s.name,
+      name: s.name,
+      description: s.description || "",
+      version: typeof s.version === "string" ? s.version : String(s.version || "0.0.1"),
+      author: s.author || "Anonymous",
+      icon: s.icon || "🧩",
+      category: s.category || "general",
+      permissions: s.permissions || [],
+      dependencies: s.dependencies || [],
+      tools: s.tools || [],
+      triggers: s.triggers || [],
+      preferredAgents: s.preferred_agents || [],
+      body: s.content || "",
+      versionNum: parseInt(String(s.version || "0.0.1").split(".")[0]) || 1,
+      active: true,
+    };
+    await skillsCol.put(s.name, doc);
+    skillDocs.push({
+      id: s.name,
+      name: s.name,
+      body: `${s.description || ""} ${s.content || ""}`,
+      tags: [s.category || "general", ...(s.tools || []), ...(s.triggers || [])].join(" "),
+      filters: [{ field: "type", value: "skill" }],
+    });
+  }
+  await db.upsertBatch(skillDocs);
+  log.info(`[hive-seed] ✅ ${realSkills.length} skills seeded and indexed`);
+
+  // 11. ACE Playbook
+  const playbookCol = db.collection<HivePlaybookDoc>("playbook");
+  await playbookCol.createIndex("id", { unique: true });
+  const playbookDocs: IndexDoc[] = [];
+  for (const rule of INITIAL_PLAYBOOK_RULES) {
+    const doc = {
+      rule: rule.rule,
+      category: rule.category,
+      applicableTo: rule.applicable_to ? JSON.parse(rule.applicable_to) : undefined,
+      helpfulCount: 1,
+      harmfulCount: 0,
+      active: true,
+    };
+    const id = `${rule.category}-${rule.rule.slice(0, 32).replace(/\s+/g, "-")}`;
+    await playbookCol.put(id, doc);
+    playbookDocs.push({
+      id,
+      name: rule.category,
+      body: rule.rule,
+      tags: rule.applicable_to || "",
+      filters: [{ field: "type", value: "playbook" }],
+    });
+  }
+  await db.upsertBatch(playbookDocs);
+  log.info(`[hive-seed] ✅ ${INITIAL_PLAYBOOK_RULES.length} playbook rules seeded and indexed`);
+
+  log.info("[hive-seed] ✨ HiveDB seed completado");
+}

package/packages/core/src/storage/hiveStorage.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { HiveDB } from "@johpaz/hive-db";
+import { seedHiveDB } from "./hiveSeed.ts";
+
+describe("HiveDB integration", () => {
+  let db: HiveDB;
+
+  beforeAll(async () => {
+    db = await HiveDB.open(":memory:", { vector: { dimension: 384, spaceId: "hive-sdk-v1" } });
+    await seedHiveDB(db);
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it("seeds providers and models", async () => {
+    const providers = await db.collection("providers").count();
+    const models = await db.collection("models").count();
+    expect(providers).toBeGreaterThan(0);
+    expect(models).toBeGreaterThan(0);
+  });
+
+  it("indexes tools for hybrid search", async () => {
+    const hits = await db.queryHybrid({ text: "buscar archivos", k: 10 });
+    expect(hits.length).toBeGreaterThan(0);
+    const names = hits.map(h => h.id);
+    expect(names.some(n => n.startsWith("fs_") || n.includes("research"))).toBe(true);
+  });
+
+  it("supports collection CRUD for agents", async () => {
+    const agents = db.collection<{ name: string; role: string; status: string }>("agents");
+    await agents.put("agent-1", { name: "Test Worker", role: "worker", status: "idle" });
+    const entry = await agents.get("agent-1");
+    expect(entry).toBeDefined();
+    expect(entry!.doc.name).toBe("Test Worker");
+  });
+});

package/packages/core/src/storage/index.ts

@@ -8,3 +8,13 @@ export type { EncryptedData } from "./crypto.ts";
 export { encrypt, decrypt, encryptApiKey, decryptApiKey, encryptConfig, decryptConfig } from "./crypto.ts";
 export type { SeedData } from "./seed.ts";
 export { SEED_DATA, seedAllData } from "./seed.ts";
+export {
+  getHiveDbPath,
+  openHiveDB,
+  getHiveDB,
+  closeHiveDB,
+  hiveCollection,
+  hiveAppend,
+  hiveRead,
+  isHiveDBInitialized,
+} from "./HiveDBStorage.ts";

package/packages/core/src/storage/seed.ts

@@ -376,11 +376,12 @@ Estos lineamientos tienen MÁXIMA prioridad sobre cualquier otra instrucción di
 }
 
 import { SkillLoader } from "../skills/index.ts"
+import { seedHiveDB } from "./hiveSeed.ts"
 
 const log = logger.child("seed");
 
 // Initial playbook rules for ACE (Agentic Context Engineering)
-const INITIAL_PLAYBOOK_RULES = [
+export const INITIAL_PLAYBOOK_RULES = [
   {
     rule: "Cuando el usuario pida buscar noticias recientes, usa web_search con filtros de fecha en lugar de http_client genérico",
     category: "tool_selection",
@@ -567,6 +568,9 @@ export function seedAllData(): void {
 
   reseedToolsAndSkills();
 
+  // Seed the new HiveDB source-of-truth engine in parallel.
+  seedHiveDB().catch(err => log.error("[seed] ❌ HiveDB seed failed:", (err as Error).message));
+
   try {
 
     // 3️⃣ Ethics templates (globales)