@johpaz/hive-sdk 0.0.18 → 0.1.3

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

@@ -6,148 +6,32 @@
 
 import type { Tool } from "../types.ts";
 import { getDb } from "../../storage/SQLiteStorage.ts";
+import { getHiveDB } from "../../storage/HiveDBStorage.ts";
 import { logger } from "../../utils/logger.ts";
 
 const log = logger.child("core");
 
-// ─── Bilingual dictionary: Spanish → English ────────────────────────────────
-
-const ES_EN_DICT: Record<string, string[]> = {
-  // Acciones
-  "buscar": ["search", "find", "list", "get", "query"],
-  "listar": ["list", "get", "fetch", "retrieve"],
-  "crear": ["create", "add", "insert", "new", "make"],
-  "actualizar": ["update", "edit", "modify", "change"],
-  "eliminar": ["delete", "remove", "destroy"],
-  "obtener": ["get", "fetch", "retrieve", "read"],
-  "enviar": ["send", "post", "submit", "push"],
-  "leer": ["read", "get", "fetch"],
-  "escribir": ["write", "create", "save"],
-  "modificar": ["update", "modify", "edit", "change"],
-  "ejecutar": ["execute", "run", "invoke"],
-  "conectar": ["connect", "link"],
-  "desconectar": ["disconnect", "remove"],
-  "descargar": ["download", "export", "fetch"],
-  "subir": ["upload", "import", "create"],
-  "analizar": ["analyze", "review", "examine"],
-  "generar": ["generate", "create", "produce"],
-  "convertir": ["convert", "transform", "translate"],
-  "validar": ["validate", "verify", "check"],
-  "importar": ["import", "load", "ingest"],
-  "exportar": ["export", "download", "extract"],
-  "comprimir": ["compress", "zip", "archive"],
-  "extraer": ["extract", "get", "retrieve", "parse"],
-  "reemplazar": ["replace", "update", "swap"],
-  "cargar": ["load", "import", "upload"],
-  "guardar": ["save", "store", "create"],
-  "consultar": ["query", "search", "get", "list"],
-  "registrar": ["register", "create", "log", "record"],
-  "programar": ["schedule", "plan", "cron"],
-  "notificar": ["notify", "alert", "send"],
-  "reiniciar": ["restart", "reset", "reboot"],
-  "configurar": ["configure", "setup", "set"],
-  "autenticar": ["authenticate", "login", "auth"],
-  "publicar": ["publish", "deploy", "release"],
-  "desplegar": ["deploy", "publish", "release"],
-  "copiar": ["copy", "clone", "duplicate"],
-  "mover": ["move", "transfer", "migrate"],
-  "comparar": ["compare", "diff", "match"],
-  "fusionar": ["merge", "combine", "join"],
-  "dividir": ["split", "divide", "partition"],
-  "filtrar": ["filter", "search", "query"],
-  "ordenar": ["sort", "order", "arrange"],
-  "traducir": ["translate", "convert"],
-
-  // Entidades
-  "base": ["base", "database", "db"],
-  "bases": ["bases", "databases"],
-  "datos": ["data", "records", "rows", "entries"],
-  "registro": ["record", "entry", "row", "item"],
-  "registros": ["records", "entries", "rows", "items"],
-  "tabla": ["table", "schema", "collection"],
-  "tablas": ["tables", "schemas"],
-  "campo": ["field", "column", "property"],
-  "campos": ["fields", "columns", "properties"],
-  "usuario": ["user", "account"],
-  "usuarios": ["users", "accounts"],
-  "proyecto": ["project", "repo", "workspace"],
-  "proyectos": ["projects", "repos", "workspaces"],
-  "archivo": ["file", "document"],
-  "archivos": ["files", "documents"],
-  "correo": ["email", "mail", "message"],
-  "correos": ["emails", "mails", "messages"],
-  "noticia": ["news", "article", "post"],
-  "noticias": ["news", "articles", "posts"],
-  "contenido": ["content", "data", "text"],
-  "tarea": ["task", "job", "issue", "ticket"],
-  "tareas": ["tasks", "jobs", "issues", "tickets"],
-  "pagina": ["page", "site", "web"],
-  "enlace": ["link", "url", "reference"],
-  "imagen": ["image", "picture", "photo"],
-  "video": ["video", "media"],
-  "audio": ["audio", "sound", "media"],
-  "categoria": ["category", "tag", "label"],
-  "estado": ["status", "state", "condition"],
-  "error": ["error", "exception", "fault"],
-  "fuente": ["source", "origin", "reference"],
-  "esquema": ["schema", "structure", "model"],
-  "respuesta": ["response", "reply", "answer"],
-  "solicitud": ["request", "query", "call"],
-  "repositorio": ["repository", "repo"],
-  "seguridad": ["security", "auth", "permission"],
-  "permiso": ["permission", "role", "access"],
-  "acceso": ["access", "login", "entry"],
-  "servidor": ["server", "host", "service"],
-  "conexion": ["connection", "link", "integration"],
-  "integracion": ["integration", "connector", "plugin"],
-  "herramienta": ["tool", "utility", "function"],
-  "informacion": ["info", "information", "details"],
-  "lista": ["list", "collection", "array"],
-  "reporte": ["report", "summary", "analytics"],
-  "metrica": ["metric", "stat", "analytics"],
-  "contacto": ["contact", "lead", "person"],
-};
-
-/**
- * Translate a Spanish query to English equivalents for FTS5 fallback.
- * Returns an array of English keyword tokens.
- */
-function translateQueryToEnglish(query: string): string {
-  const words = query.toLowerCase().replace(/_/g, " ").split(/\s+/).filter(w => w.length > 1);
-  const translated: string[] = [];
-
-  for (const word of words) {
-    const equivalents = ES_EN_DICT[word];
-    if (equivalents) {
-      translated.push(...equivalents);
-    }
-  }
-
-  return [...new Set(translated)].join(" ");
-}
+// ─── search_knowledge ────────────────────────────────────────────────────────
 
-/**
- * Build an FTS5 MATCH expression from a list of words.
- * Multi-word: AND with prefix wildcard. Single: exact OR prefix.
- */
-function buildFtsMatch(words: string[]): string {
-  if (words.length > 1) {
-    return words.map(w => `${w}*`).join(' AND ');
-  }
-  return `"${words.join(' ')}" OR ${words[0]}*`;
+function buildSearchQuery(query: string): string {
+  return query
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, " ")
+    .split(/\s+/)
+    .filter(w => w.length > 2)
+    .slice(0, 8)
+    .join(" ");
 }
 
-// ─── search_knowledge ────────────────────────────────────────────────────────
-
 export const searchKnowledgeTool: Tool = {
   name: "search_knowledge",
-  description: "Busca herramientas NATIVAS (tools), MCP (tools externas), habilidades (skills) o reglas del playbook en la base de conocimientos. Usa búsqueda full-text (FTS5) con fallback bilingüe español→inglés. type='mcp' para herramientas MCP, type='all' para buscar en todo.",
+  description: "Busca herramientas NATIVAS (tools), MCP (tools externas), habilidades (skills) o reglas del playbook en la base de conocimientos. Usa búsqueda híbrida (BM25 + vector). type='mcp' para herramientas MCP, type='all' para buscar en todo.",
   parameters: {
     type: "object",
     properties: {
       query: {
         type: "string",
-        description: "Término de búsqueda (nombre, descripción, categoría). Se busca primero en español, luego en inglés si hay pocos resultados.",
+        description: "Término de búsqueda (nombre, descripción, categoría).",
       },
       type: {
         type: "string",
@@ -162,179 +46,105 @@ export const searchKnowledgeTool: Tool = {
     required: ["query"],
   },
   execute: async (params: Record<string, unknown>) => {
-    const db = getDb();
+    const db = await getHiveDB();
     const query = params.query as string;
     const type = (params.type as string) ?? "all";
     const limit = (params.limit as number) ?? 10;
-    const MIN_RESULTS_FOR_BILINGUAL = 2;
 
     try {
-      const escapedQuery = query.replace(/'/g, "''");
-      const normalizedQuery = escapedQuery.replace(/_/g, " ").trim();
-      const words = normalizedQuery.split(/\s+/).filter(w => w.length > 0);
-      const ftsMatch = buildFtsMatch(words);
+      const searchQuery = buildSearchQuery(query);
+      if (!searchQuery) {
+        return { ok: true, query, type, tools: [], skills: [], playbook: [], toolsmcp: [], totalResults: 0 };
+      }
 
       const result: any = { query, type, tools: [], skills: [], playbook: [], toolsmcp: [] };
 
-      // ─── Search functions (reusable for bilingual fallback) ───────────
-
-      function searchTools(matchExpr: string): any[] {
-        if (type !== "all" && type !== "tools") return [];
-        try {
-          return db.query(`
-            SELECT
-              COALESCE(t.id, tools_fts.tool_name) as id,
-              COALESCE(t.name, tools_fts.tool_name) as name,
-              COALESCE(t.description, tools_fts.description) as description,
-              COALESCE(t.category, tools_fts.category) as category,
-              COALESCE(t.enabled, 1) as enabled,
-              COALESCE(t.active, 1) as active,
-              bm25(tools_fts) as rank
-            FROM tools_fts
-            LEFT JOIN tools t ON t.name = tools_fts.tool_name
-            WHERE tools_fts MATCH ?
-            ORDER BY rank
-            LIMIT ?
-          `).all(matchExpr, limit) as any[];
-        } catch { return []; }
+      async function searchByType(docType: string) {
+        return db.queryHybrid({
+          text: searchQuery,
+          k: limit,
+          filters: [{ field: "type", value: docType }],
+          boosts: { name: 5.0, body: 3.0, tags: 2.0 },
+        });
       }
 
-      function searchSkills(matchExpr: string): any[] {
-        if (type !== "all" && type !== "skills") return [];
-        try {
-          return db.query(`
-            SELECT s.id, s.name, s.description, s.category, s.tools, s.triggers, s.preferred_agents, s.body, s.active, bm25(skills_fts) as rank
-            FROM skills_fts
-            JOIN skills s ON s.id = skills_fts.id
-            WHERE skills_fts MATCH ?
-            ORDER BY rank
-            LIMIT ?
-          `).all(matchExpr, limit) as any[];
-        } catch { return []; }
+      if (type === "all" || type === "tools") {
+        const hits = await searchByType("tool");
+        const toolsCol = db.collection<{ name: string; description: string; category: string; enabled: boolean; active: boolean }>("tools");
+        for (const hit of hits) {
+          const entry = await toolsCol.get(hit.id);
+          const doc = entry?.doc;
+          result.tools.push({
+            id: hit.id,
+            name: doc?.name ?? hit.id,
+            description: doc?.description ?? "",
+            category: doc?.category ?? "core",
+            enabled: doc?.enabled ?? true,
+            active: doc?.active ?? true,
+            rank: hit.score,
+          });
+        }
       }
 
-      function searchPlaybook(matchExpr: string): any[] {
-        if (type !== "all" && type !== "playbook") return [];
-        try {
-          return db.query(`
-            SELECT p.id, p.rule, p.category, p.applicable_to, p.helpful_count, p.harmful_count, p.active, bm25(playbook_fts) as rank
-            FROM playbook_fts
-            JOIN playbook p ON p.id = playbook_fts.rowid
-            WHERE playbook_fts MATCH ?
-            ORDER BY rank
-            LIMIT ?
-          `).all(matchExpr, limit) as any[];
-        } catch { return []; }
+      if (type === "all" || type === "skills") {
+        const hits = await searchByType("skill");
+        const skillsCol = db.collection<{ name: string; description: string; category: string; body: string; tools: string[]; triggers: string[]; active: boolean }>("skills");
+        for (const hit of hits) {
+          const entry = await skillsCol.get(hit.id);
+          const doc = entry?.doc;
+          result.skills.push({
+            id: hit.id,
+            name: doc?.name ?? hit.id,
+            description: doc?.description ?? "",
+            category: doc?.category ?? "general",
+            tools: doc?.tools ?? [],
+            triggers: doc?.triggers ?? [],
+            body: doc?.body ? (doc.body.length > 400 ? doc.body.substring(0, 400) + "…" : doc.body) : undefined,
+            active: doc?.active ?? true,
+            rank: hit.score,
+          });
+        }
       }
 
-      function searchMcpTools(matchExpr: string): any[] {
-        if (type !== "all" && type !== "mcp") return [];
-        try {
-          return db.query(`
-            SELECT m.id, m.server_name, m.tool_name, m.description, m.category, m.active, bm25(mcp_tools_fts) as rank
-            FROM mcp_tools_fts
-            JOIN mcp_tools m ON m.id = mcp_tools_fts.id
-            WHERE mcp_tools_fts MATCH ?
-            ORDER BY rank
-            LIMIT ?
-          `).all(matchExpr, limit) as any[];
-        } catch { return []; }
+      if (type === "all" || type === "playbook") {
+        const hits = await searchByType("playbook");
+        const playbookCol = db.collection<{ rule: string; category: string; applicableTo?: string[]; active: boolean }>("playbook");
+        for (const hit of hits) {
+          const entry = await playbookCol.get(hit.id);
+          const doc = entry?.doc;
+          result.playbook.push({
+            id: hit.id,
+            rule: doc?.rule ?? "",
+            category: doc?.category ?? "",
+            applicable_to: doc?.applicableTo ?? null,
+            active: doc?.active ?? true,
+            rank: hit.score,
+          });
+        }
       }
 
-      // ─── Pass 1: Search with original query ─────────────────────────
-
-      const tools1 = searchTools(ftsMatch);
-      const skills1 = searchSkills(ftsMatch);
-      const playbook1 = searchPlaybook(ftsMatch);
-      const mcp1 = searchMcpTools(ftsMatch);
-
-      const totalFirst = tools1.length + skills1.length + playbook1.length + mcp1.length;
-
-      // Map results
-      result.tools = tools1.map((t: any) => ({
-        id: t.id, name: t.name, description: t.description, category: t.category,
-        enabled: t.enabled === 1, active: t.active === 1, rank: t.rank,
-      }));
-      result.skills = skills1.map((s: any) => ({
-        id: s.id, name: s.name, description: s.description, category: s.category,
-        tools: s.tools, triggers: s.triggers,
-        preferred_agents: s.preferred_agents ? JSON.parse(s.preferred_agents) : [],
-        body: s.body ? (s.body.length > 400 ? s.body.substring(0, 400) + "…" : s.body) : undefined,
-        active: s.active === 1, rank: s.rank,
-      }));
-      result.playbook = playbook1.map((p: any) => ({
-        id: p.id, rule: p.rule, category: p.category,
-        applicable_to: p.applicable_to ? JSON.parse(p.applicable_to) : null,
-        helpful_count: p.helpful_count, harmful_count: p.harmful_count,
-        active: p.active === 1, rank: p.rank,
-      }));
-      result.toolsmcp = mcp1.map((t: any) => ({
-        id: t.id, full_name: t.id, server_name: t.server_name, tool_name: t.tool_name,
-        description: t.description, category: t.category,
-        active: t.active === 1, rank: t.rank,
-      }));
-
-      // ─── Pass 2: Bilingual fallback (ES → EN) ──────────────────────
-
-      if (totalFirst < MIN_RESULTS_FOR_BILINGUAL) {
-        const englishQuery = translateQueryToEnglish(normalizedQuery);
-        if (englishQuery.length > 0) {
-          const enWords = englishQuery.split(/\s+/).filter(w => w.length > 0);
-          const enMatch = buildFtsMatch(enWords);
-
-          log.info(`[search_knowledge] Bilingual fallback: "${normalizedQuery}" → "${englishQuery}" (first pass: ${totalFirst} results)`);
-
-          const existingIds = new Set([
-            ...result.tools.map((t: any) => t.name),
-            ...result.skills.map((s: any) => s.id),
-            ...result.playbook.map((p: any) => p.id),
-            ...result.toolsmcp.map((t: any) => t.id),
-          ]);
-
-          // Merge English results (dedup by id)
-          for (const t of searchTools(enMatch)) {
-            if (!existingIds.has(t.name || t.id)) {
-              result.tools.push({
-                id: t.id, name: t.name, description: t.description, category: t.category,
-                enabled: t.enabled === 1, active: t.active === 1, rank: t.rank,
-              });
-              existingIds.add(t.name || t.id);
-            }
-          }
-          for (const s of searchSkills(enMatch)) {
-            if (!existingIds.has(s.id)) {
-              result.skills.push({
-                id: s.id, name: s.name, description: s.description, category: s.category,
-                tools: s.tools, triggers: s.triggers,
-                preferred_agents: s.preferred_agents ? JSON.parse(s.preferred_agents) : [],
-                body: s.body ? (s.body.length > 400 ? s.body.substring(0, 400) + "…" : s.body) : undefined,
-                active: s.active === 1, rank: s.rank,
-              });
-              existingIds.add(s.id);
-            }
-          }
-          for (const p of searchPlaybook(enMatch)) {
-            if (!existingIds.has(p.id)) {
-              result.playbook.push({
-                id: p.id, rule: p.rule, category: p.category,
-                applicable_to: p.applicable_to ? JSON.parse(p.applicable_to) : null,
-                helpful_count: p.helpful_count, harmful_count: p.harmful_count,
-                active: p.active === 1, rank: p.rank,
-              });
-              existingIds.add(p.id);
-            }
-          }
-          for (const t of searchMcpTools(enMatch)) {
-            if (!existingIds.has(t.id)) {
-              result.toolsmcp.push({
-                id: t.id, full_name: t.id, server_name: t.server_name, tool_name: t.tool_name,
-                description: t.description, category: t.category,
-                active: t.active === 1, rank: t.rank,
-              });
-              existingIds.add(t.id);
-            }
-          }
-        }
+      if (type === "all" || type === "mcp") {
+        const mcpCol = db.collection<{ serverName: string; toolName: string; description: string; category: string; active: boolean }>("mcp_tools");
+        const entries = await mcpCol.scan();
+        const q = searchQuery.toLowerCase();
+        const matches = entries
+          .map(e => e.doc)
+          .filter(m => m.active && (
+            m.toolName.toLowerCase().includes(q) ||
+            m.description.toLowerCase().includes(q) ||
+            m.category.toLowerCase().includes(q)
+          ))
+          .slice(0, limit);
+        result.toolsmcp = matches.map(m => ({
+          id: `${m.serverName}__${m.toolName}`,
+          full_name: `${m.serverName}__${m.toolName}`,
+          server_name: m.serverName,
+          tool_name: m.toolName,
+          description: m.description,
+          category: m.category,
+          active: true,
+          rank: 0,
+        }));
       }
 
       result.totalResults = result.tools.length + result.skills.length + result.playbook.length + result.toolsmcp.length;
@@ -380,6 +190,13 @@ export const notifyTool: Tool = {
 
 // ─── save_note (scratchpad) ──────────────────────────────────────────────────
 
+interface ScratchpadDoc {
+  threadId: string;
+  key: string;
+  value: string;
+  updatedAt: number;
+}
+
 export const saveNoteTool: Tool = {
   name: "save_note",
   description: "Save a note to the scratchpad (survives context compression).",
@@ -402,16 +219,14 @@ export const saveNoteTool: Tool = {
     required: ["key", "value"],
   },
   execute: async (params: Record<string, unknown>, config?: any) => {
-    const db = getDb();
+    const db = await getHiveDB();
     const key = params.key as string;
     const value = params.value as string;
     const threadId = (params.thread_id as string) ?? config?.configurable?.thread_id ?? "default";
 
     try {
-      db.query(`
-        INSERT OR REPLACE INTO scratchpad (thread_id, key, value, source, updated_at)
-        VALUES (?, ?, ?, 'agent', unixepoch())
-      `).run(threadId, key, value);
+      const col = db.collection<ScratchpadDoc>("scratchpad");
+      await col.put(`${threadId}:${key}`, { threadId, key, value, updatedAt: Date.now() });
 
       return { ok: true, key, message: "Note saved." };
     } catch (error) {
@@ -473,4 +288,4 @@ export const reportProgressTool: Tool = {
 
 export function createTools(): Tool[] {
   return [searchKnowledgeTool, notifyTool, saveNoteTool, reportProgressTool];
-}
+}