@johpaz/hive-sdk 0.0.12 → 0.0.15

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/projects/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Projects Tools - 8 tools
+ * 
+ * @category projects
+ */
+
+import type { Tool } from "../types.ts";
+import { projectCreateTool } from "./project-create.ts";
+import { projectListTool } from "./project-list.ts";
+import { projectUpdateTool } from "./project-update.ts";
+import { projectDoneTool } from "./project-done.ts";
+import { projectFailTool } from "./project-fail.ts";
+import { taskCreateTool } from "./task-create.ts";
+import { taskUpdateTool } from "./task-update.ts";
+import { taskEvaluateTool } from "./task-evaluate.ts";
+
+export function createTools(): Tool[] {
+  return [
+    projectCreateTool,
+    projectListTool,
+    projectUpdateTool,
+    projectDoneTool,
+    projectFailTool,
+    taskCreateTool,
+    taskUpdateTool,
+    taskEvaluateTool,
+  ];
+}
+
+export * from "./project-create.ts";
+export * from "./project-list.ts";
+export * from "./project-update.ts";
+export * from "./project-done.ts";
+export * from "./project-fail.ts";
+export * from "./task-create.ts";
+export * from "./task-update.ts";
+export * from "./task-evaluate.ts";

package/packages/core/src/tools/projects/project-create.ts

@@ -0,0 +1,94 @@
+/**
+ * project_create - Create a new project with tasks in the database
+ * 
+ * @category projects
+ * @seedId project_create
+ * @spanish crear proyecto, nuevo proyecto, iniciar plan
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+import crypto from "crypto";
+
+const log = logger.child("project-create");
+
+export const projectCreateTool: Tool = {
+  name: "project_create",
+  description: "Create a new project with tasks in the database. Spanish: crear proyecto, nuevo proyecto, iniciar plan",
+  parameters: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "Nombre descriptivo del proyecto",
+      },
+      description: {
+        type: "string",
+        description: "Descripción detallada del objetivo del proyecto",
+      },
+      type: {
+        type: "string",
+        enum: ["general", "code", "research", "content", "data"],
+        description: "Tipo de proyecto",
+      },
+      tasks: {
+        type: "array",
+        description: "Lista de tareas atómicas que componen el proyecto",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Nombre corto de la tarea" },
+            description: { type: "string", description: "Qué debe hacer esta tarea" },
+            agent_id: { type: "string", description: "ID del agente asignado (opcional)" },
+          },
+          required: ["name"],
+        },
+      },
+    },
+    required: ["name", "type"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const db = getDb();
+    const name = params.name as string;
+    const description = (params.description as string) ?? "";
+    const type = (params.type as string) ?? "general";
+    const tasks = (params.tasks as any[]) ?? [];
+    const userId = config?.configurable?.user_id;
+    const agentId = config?.configurable?.agent_id;
+
+    try {
+      const projectId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+
+      log.info(`Creating project: ${name}`);
+
+      db.query(`
+        INSERT INTO projects (id, user_id, agent_id, name, description, type, task, status, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'active', unixepoch(), unixepoch())
+      `).run(projectId, userId, agentId, name, description, type, description);
+
+      const taskIds: number[] = [];
+      for (const t of tasks) {
+        const result = db.query(`
+          INSERT INTO tasks (project_id, agent_id, name, description, status, created_at, updated_at)
+          VALUES (?, ?, ?, ?, 'pending', unixepoch(), unixepoch())
+        `).run(projectId, t.agent_id ?? agentId, t.name, t.description ?? null);
+
+        taskIds.push(result.lastInsertRowid as number);
+      }
+
+      return {
+        ok: true,
+        projectId,
+        taskIds,
+        message: `Project "${name}" created with ${tasks.length} task(s).`,
+      };
+    } catch (error) {
+      log.error(`Failed to create project: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to create project: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/project-done.ts

@@ -0,0 +1,66 @@
+/**
+ * project_done - Mark project as completed
+ * 
+ * @category projects
+ * @seedId project_done
+ * @spanish proyecto terminado, cerrar proyecto, completado
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("project-done");
+
+export const projectDoneTool: Tool = {
+  name: "project_done",
+  description: "Mark project as completed and archive it. Spanish: proyecto terminado, cerrar proyecto, completado",
+  parameters: {
+    type: "object",
+    properties: {
+      projectId: {
+        type: "string",
+        description: "ID del proyecto completado",
+      },
+      summary: {
+        type: "string",
+        description: "Resumen final de lo logrado",
+      },
+    },
+    required: ["projectId"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const db = getDb();
+    const projectId = params.projectId as string;
+    const summary = (params.summary as string) ?? "Tarea completada exitosamente.";
+
+    try {
+      log.info(`Completing project ${projectId}`);
+
+      const result = db.query(`
+        UPDATE projects 
+        SET status = 'done', progress = 100, updated_at = unixepoch(), completed_at = unixepoch(), context = ?
+        WHERE id = ?
+      `).run(summary, projectId);
+
+      if (result.changes === 0) {
+        return {
+          ok: false,
+          error: `Project not found: ${projectId}`,
+        };
+      }
+
+      return {
+        ok: true,
+        projectId,
+        message: "Project marked as completed.",
+      };
+    } catch (error) {
+      log.error(`Failed to complete project: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to complete project: ${(error as Error).message}`,
+      };
+    }
+  },
+};