@johpaz/hive-agents 0.0.34 → 0.0.36

package/packages/core/src/tools/office/office-leer-docx.ts

@@ -0,0 +1,93 @@
+/**
+ * office_leer_docx - Leer contenido de un archivo Word (.docx)
+ *
+ * @category office
+ * @seedId office_leer_docx
+ * @spanish leer word, abrir docx, extraer texto de word, contenido word
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("office-leer-docx");
+
+export const officeLeerDocxTool: Tool = {
+  name: "office_leer_docx",
+  description:
+    "Leer un archivo Word (.docx) y retornar el contenido de texto preservando párrafos y tablas. Spanish: leer word, abrir docx, extraer texto de word, contenido word",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta absoluta o relativa al archivo .docx",
+      },
+      incluir_tablas: {
+        type: "boolean",
+        description: "Incluir contenido de tablas en la extracción (default: true)",
+      },
+    },
+    required: ["ruta"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const incluirTablas = (params.incluir_tablas as boolean) ?? true;
+
+    log.debug(`Leyendo DOCX: ${ruta}`);
+
+    try {
+      const rutaAbsoluta = path.resolve(ruta);
+      if (!fs.existsSync(rutaAbsoluta)) {
+        return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
+      }
+
+      const mammoth = await import("mammoth");
+      const buffer = fs.readFileSync(rutaAbsoluta);
+
+      // Extraer texto plano
+      const resultadoTexto = await mammoth.extractRawText({ buffer });
+
+      // Extraer HTML para información de tablas si se requiere
+      let textoTablas: string | undefined;
+      if (incluirTablas) {
+        const resultadoHtml = await mammoth.convertToHtml({ buffer });
+        // Extraer contenido de tablas del HTML
+        const tablas = resultadoHtml.value.match(/<table[\s\S]*?<\/table>/gi) ?? [];
+        if (tablas.length > 0) {
+          textoTablas = tablas
+            .map((tabla, i) => {
+              // Limpiar tags HTML y extraer texto de celdas
+              const celdas = tabla.match(/<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi) ?? [];
+              const textoCeldas = celdas
+                .map((celda) => celda.replace(/<[^>]+>/g, "").trim())
+                .filter(Boolean);
+              return `[Tabla ${i + 1}]\n${textoCeldas.join(" | ")}`;
+            })
+            .join("\n\n");
+        }
+      }
+
+      const advertencias = resultadoTexto.messages
+        .filter((m: any) => m.type === "warning")
+        .map((m: any) => m.message);
+
+      log.info(`DOCX leído: ${resultadoTexto.value.length} caracteres`);
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        texto: resultadoTexto.value,
+        tablas: textoTablas,
+        advertencias: advertencias.length > 0 ? advertencias : undefined,
+      };
+    } catch (error) {
+      log.error(`Error leyendo DOCX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo leer el archivo DOCX: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/office/office-leer-pdf.ts

@@ -0,0 +1,114 @@
+/**
+ * office_leer_pdf - Leer contenido de un archivo PDF
+ *
+ * @category office
+ * @seedId office_leer_pdf
+ * @spanish leer pdf, abrir pdf, extraer texto de pdf, contenido pdf
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("office-leer-pdf");
+
+export const officeLeerPdfTool: Tool = {
+  name: "office_leer_pdf",
+  description:
+    "Leer contenido de un archivo PDF y retornar texto plano con metadata. Spanish: leer pdf, abrir pdf, extraer texto de pdf, pdf a texto",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta absoluta o relativa al archivo PDF",
+      },
+      pagina_inicio: {
+        type: "number",
+        description: "Página desde la que empezar (1-indexed, default: 1)",
+      },
+      pagina_fin: {
+        type: "number",
+        description: "Última página a leer (default: todas las páginas)",
+      },
+    },
+    required: ["ruta"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const paginaInicio = Math.max(1, (params.pagina_inicio as number) ?? 1);
+    const paginaFin = params.pagina_fin as number | undefined;
+
+    log.debug(`Leyendo PDF: ${ruta}`);
+
+    try {
+      const rutaAbsoluta = path.resolve(ruta);
+      if (!fs.existsSync(rutaAbsoluta)) {
+        return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
+      }
+
+      const buffer = fs.readFileSync(rutaAbsoluta);
+      const uint8Array = new Uint8Array(buffer);
+
+      // Importar pdfjs-dist (compatible con Bun, sin worker)
+      const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs" as any).catch(
+        () => import("pdfjs-dist" as any)
+      );
+
+      // Desactivar worker para entorno Node/Bun
+      const lib = pdfjsLib.default ?? pdfjsLib;
+      if (lib.GlobalWorkerOptions) {
+        lib.GlobalWorkerOptions.workerSrc = "";
+      }
+
+      const doc = await lib.getDocument({ data: uint8Array, disableWorker: true }).promise;
+      const totalPaginas = doc.numPages;
+
+      // Metadata
+      let titulo: string | undefined;
+      try {
+        const meta = await doc.getMetadata();
+        titulo = (meta?.info as any)?.Title ?? undefined;
+      } catch {
+        // metadata opcional
+      }
+
+      const inicio = paginaInicio;
+      const fin = paginaFin ? Math.min(paginaFin, totalPaginas) : totalPaginas;
+
+      const textosPorPagina: Array<{ pagina: number; texto: string }> = [];
+
+      for (let i = inicio; i <= fin; i++) {
+        const pagina = await doc.getPage(i);
+        const contenido = await pagina.getTextContent();
+        const texto = (contenido.items as any[])
+          .map((item: any) => item.str ?? "")
+          .join(" ")
+          .replace(/\s+/g, " ")
+          .trim();
+        textosPorPagina.push({ pagina: i, texto });
+      }
+
+      const textoCompleto = textosPorPagina.map((p) => p.texto).join("\n\n");
+
+      log.info(`PDF leído: ${totalPaginas} páginas, ${textoCompleto.length} caracteres`);
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        totalPaginas,
+        paginasLeidas: fin - inicio + 1,
+        titulo,
+        texto: textoCompleto,
+        paginas: textosPorPagina,
+      };
+    } catch (error) {
+      log.error(`Error leyendo PDF: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo leer el PDF: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/office/office-leer-pptx.ts

@@ -0,0 +1,136 @@
+/**
+ * office_leer_pptx - Leer contenido de un archivo PowerPoint (.pptx)
+ *
+ * @category office
+ * @seedId office_leer_pptx
+ * @spanish leer powerpoint, abrir pptx, extraer texto de presentacion, contenido slides
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("office-leer-pptx");
+
+export const officeLeerPptxTool: Tool = {
+  name: "office_leer_pptx",
+  description:
+    "Leer un archivo PowerPoint (.pptx) y retornar el texto de cada diapositiva como array estructurado. Spanish: leer powerpoint, abrir pptx, extraer texto de presentacion, contenido slides",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta absoluta o relativa al archivo .pptx",
+      },
+      solo_diapositiva: {
+        type: "number",
+        description:
+          "Número de diapositiva específica a leer (1-indexed, default: todas)",
+      },
+    },
+    required: ["ruta"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const soloSlide = params.solo_diapositiva as number | undefined;
+
+    log.debug(`Leyendo PPTX: ${ruta}`);
+
+    try {
+      const rutaAbsoluta = path.resolve(ruta);
+      if (!fs.existsSync(rutaAbsoluta)) {
+        return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
+      }
+
+      const JSZip = (await import("jszip")).default;
+      const buffer = fs.readFileSync(rutaAbsoluta);
+      const zip = await JSZip.loadAsync(buffer);
+
+      // Encontrar todos los archivos de slides
+      const archivosSlides = Object.keys(zip.files)
+        .filter((nombre) => /^ppt\/slides\/slide\d+\.xml$/i.test(nombre))
+        .sort((a, b) => {
+          const numA = parseInt(a.match(/slide(\d+)/)?.[1] ?? "0");
+          const numB = parseInt(b.match(/slide(\d+)/)?.[1] ?? "0");
+          return numA - numB;
+        });
+
+      const diapositivas: Array<{
+        numero: number;
+        titulo?: string;
+        texto: string;
+        fragmentos: string[];
+      }> = [];
+
+      for (let i = 0; i < archivosSlides.length; i++) {
+        const numeroSlide = i + 1;
+
+        if (soloSlide !== undefined && numeroSlide !== soloSlide) {
+          continue;
+        }
+
+        const archivoSlide = archivosSlides[i];
+        const xmlContenido = await zip.files[archivoSlide].async("string");
+
+        // Extraer texto de elementos <a:t> (texto en slides de OOXML)
+        const fragmentos: string[] = [];
+        const regexTexto = /<a:t[^>]*>([\s\S]*?)<\/a:t>/g;
+        let match;
+
+        while ((match = regexTexto.exec(xmlContenido)) !== null) {
+          const texto = match[1]
+            .replace(/&amp;/g, "&")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&quot;/g, '"')
+            .replace(/&apos;/g, "'")
+            .trim();
+
+          if (texto) {
+            fragmentos.push(texto);
+          }
+        }
+
+        // Intentar extraer el título (elemento <p:sp> con tipo "title")
+        let titulo: string | undefined;
+        const regexTitulo =
+          /<p:ph[^>]*type="title"[^>]*\/>[\s\S]*?<a:t[^>]*>([\s\S]*?)<\/a:t>/;
+        const matchTitulo = regexTitulo.exec(xmlContenido);
+        if (matchTitulo) {
+          titulo = matchTitulo[1].trim();
+        } else if (fragmentos.length > 0) {
+          // Primer fragmento como título tentativo
+          titulo = fragmentos[0];
+        }
+
+        const texto = fragmentos.join(" ").replace(/\s+/g, " ").trim();
+
+        diapositivas.push({
+          numero: numeroSlide,
+          titulo,
+          texto,
+          fragmentos,
+        });
+      }
+
+      log.info(
+        `PPTX leído: ${archivosSlides.length} slides totales, ${diapositivas.length} leídas`
+      );
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        totalDiapositivas: archivosSlides.length,
+        diapositivas,
+      };
+    } catch (error) {
+      log.error(`Error leyendo PPTX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo leer el archivo PowerPoint: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/office/office-leer-xlsx.ts

@@ -0,0 +1,124 @@
+/**
+ * office_leer_xlsx - Leer un archivo Excel (.xlsx)
+ *
+ * @category office
+ * @seedId office_leer_xlsx
+ * @spanish leer excel, abrir xlsx, extraer datos de excel, hojas excel
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("office-leer-xlsx");
+
+export const officeLeerXlsxTool: Tool = {
+  name: "office_leer_xlsx",
+  description:
+    "Leer un archivo Excel (.xlsx) y retornar las hojas con sus datos como objetos JSON. Spanish: leer excel, abrir xlsx, extraer datos de excel, hojas excel",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta absoluta o relativa al archivo .xlsx",
+      },
+      hoja: {
+        type: "string",
+        description: "Nombre de hoja específica a leer (default: todas las hojas)",
+      },
+      incluir_encabezados: {
+        type: "boolean",
+        description:
+          "Usar primera fila como encabezados de columna (default: true)",
+      },
+      rango: {
+        type: "string",
+        description:
+          "Rango de celdas a leer en notación Excel (ej: 'A1:D10', default: toda la hoja)",
+      },
+    },
+    required: ["ruta"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const hojaFiltro = params.hoja as string | undefined;
+    const incluirEncabezados = (params.incluir_encabezados as boolean) ?? true;
+    const rango = params.rango as string | undefined;
+
+    log.debug(`Leyendo XLSX: ${ruta}`);
+
+    try {
+      const rutaAbsoluta = path.resolve(ruta);
+      if (!fs.existsSync(rutaAbsoluta)) {
+        return { ok: false, error: `Archivo no encontrado: ${rutaAbsoluta}` };
+      }
+
+      const XLSX = await import("xlsx");
+      const buffer = fs.readFileSync(rutaAbsoluta);
+      const workbook = XLSX.read(buffer, { type: "buffer" });
+
+      const nombresHojas = hojaFiltro
+        ? [hojaFiltro]
+        : workbook.SheetNames;
+
+      const hojas: Record<string, any[]> = {};
+
+      for (const nombreHoja of nombresHojas) {
+        const hoja = workbook.Sheets[nombreHoja];
+        if (!hoja) {
+          log.warn(`Hoja '${nombreHoja}' no encontrada en el archivo`);
+          continue;
+        }
+
+        const opciones: any = {
+          header: incluirEncabezados ? 1 : 1,
+          defval: "",
+        };
+
+        if (rango) {
+          opciones.range = rango;
+        }
+
+        if (incluirEncabezados) {
+          // La primera fila se usa como encabezados
+          hojas[nombreHoja] = XLSX.utils.sheet_to_json(hoja, {
+            defval: "",
+            range: rango,
+          });
+        } else {
+          // Devolver como array de arrays (sin encabezados)
+          hojas[nombreHoja] = XLSX.utils.sheet_to_json(hoja, {
+            header: 1,
+            defval: "",
+            range: rango,
+          });
+        }
+      }
+
+      const totalFilas = Object.values(hojas).reduce(
+        (acc, filas) => acc + filas.length,
+        0
+      );
+
+      log.info(
+        `XLSX leído: ${nombresHojas.length} hojas, ${totalFilas} filas totales`
+      );
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        hojas: workbook.SheetNames,
+        datos: hojas,
+        totalFilas,
+      };
+    } catch (error) {
+      log.error(`Error leyendo XLSX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo leer el archivo Excel: ${(error as Error).message}`,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,39 @@
+/**
+ * Tool Type Definitions
+ * Shared across all tool categories
+ * 
+ * These types are used by all 52 native tools in Hive
+ */
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    type: "object";
+    properties: Record<string, ToolParameter>;
+    required?: string[];
+  };
+  execute: (
+    params: Record<string, unknown>,
+    config?: any
+  ) => Promise<string | object>;
+}
+
+export interface ToolParameter {
+  type: string;
+  description?: string;
+  enum?: string[];
+  items?: ToolParameter;
+  properties?: Record<string, ToolParameter>;
+  required?: string[];
+  minimum?: number;
+  maximum?: number;
+  additionalProperties?: boolean | ToolParameter;
+}
+
+export interface ToolResult {
+  ok: boolean;
+  result?: any;
+  error?: string;
+  hint?: string;
+}

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

@@ -0,0 +1,104 @@
+/**
+ * Voice Tools - 2 tools
+ * 
+ * @category voice
+ */
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("voice");
+
+// ─── voice_transcribe ────────────────────────────────────────────────────────
+
+export const voiceTranscribeTool: Tool = {
+  name: "voice_transcribe",
+  description: "Transcribe audio input to text. Spanish: transcribir audio, voz a texto, reconocimiento de voz",
+  parameters: {
+    type: "object",
+    properties: {
+      audio: {
+        type: "string",
+        description: "Audio file path or base64 encoded audio",
+      },
+      language: {
+        type: "string",
+        description: "Language code (e.g., 'es', 'en'). Auto-detect if not specified.",
+      },
+    },
+    required: ["audio"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const audio = params.audio as string;
+    const language = (params.language as string) ?? "auto";
+
+    log.info(`Transcribing audio: ${audio.substring(0, 50)}...`);
+
+    try {
+      // Placeholder implementation - real transcription would call STT API
+      return {
+        ok: true,
+        transcription: "[Transcription requires STT provider configuration]",
+        language: language,
+        duration: 0,
+        confidence: 0,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to transcribe: ${(error as Error).message}`,
+      };
+    }
+  },
+};
+
+// ─── voice_speak ─────────────────────────────────────────────────────────────
+
+export const voiceSpeakTool: Tool = {
+  name: "voice_speak",
+  description: "Convert text to synthesized speech output. Spanish: texto a voz, sintetizar, hablar, leer en voz alta",
+  parameters: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Text to convert to speech",
+      },
+      voice_id: {
+        type: "string",
+        description: "Voice ID to use (provider-specific)",
+      },
+      language: {
+        type: "string",
+        description: "Language code (e.g., 'es', 'en')",
+      },
+    },
+    required: ["text"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const text = params.text as string;
+    const voiceId = (params.voice_id as string) ?? "default";
+    const language = (params.language as string) ?? "es";
+
+    log.info(`Synthesizing speech: ${text.substring(0, 50)}...`);
+
+    try {
+      // Placeholder implementation - real TTS would call TTS API
+      return {
+        ok: true,
+        audio_url: "[TTS requires provider configuration]",
+        voice_id: voiceId,
+        language: language,
+        duration: 0,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to synthesize speech: ${(error as Error).message}`,
+      };
+    }
+  },
+};
+
+export function createTools(): Tool[] {
+  return [voiceTranscribeTool, voiceSpeakTool];
+}

package/packages/core/src/tools/web/browser-click.ts

@@ -0,0 +1,78 @@
+/**
+ * browser_click - Click on a web page element
+ *
+ * @category web
+ * @seedId browser_click
+ * @spanish hacer clic, botón, enlace, interactuar
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { getBrowserService } from "./browser-service.ts";
+
+const log = logger.child("browser-click");
+
+export const browserClickTool: Tool = {
+  name: "browser_click",
+  description: "Click on a web page element. Spanish: hacer clic, botón, enlace, interactuar",
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "CSS selector of the element to click",
+      },
+      url: {
+        type: "string",
+        description: "URL to navigate to before clicking (optional)",
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)",
+      },
+    },
+    required: ["selector"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const selector = params.selector as string;
+    const url = params.url as string | undefined;
+    const timeout = (params.timeout as number) ?? 30000;
+
+    const browserService = getBrowserService();
+    if (!browserService?.isAvailable()) {
+      log.warn("Browser not available");
+      return {
+        ok: false,
+        error: "Browser automation not available. Install Chrome/Chromium.",
+      };
+    }
+
+    log.info(`Clicking: ${selector}${url ? ` on ${url}` : ""}`);
+
+    try {
+      const view = await browserService.getView();
+      if (!view) return { ok: false, error: "Browser automation not available. Install Chrome/Chromium." };
+
+      if (url) {
+        await view.navigate(url);
+        await Bun.sleep(500);
+      }
+
+      // click(selector) already waits for element actionability
+      await view.click(selector, { timeout });
+
+      const currentUrl = view.url;
+      log.info(`Click successful: ${selector} on ${currentUrl}`);
+
+      return {
+        ok: true,
+        message: `Successfully clicked element: ${selector}`,
+        selector,
+        url: currentUrl,
+      };
+    } catch (error) {
+      log.error(`Click failed: ${(error as Error).message}`);
+      return { ok: false, error: `Failed to click: ${(error as Error).message}` };
+    }
+  },
+};