@johpaz/hive-sdk 0.0.12 → 0.0.15

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

@@ -0,0 +1,192 @@
+/**
+ * office_escribir_docx - Generar un archivo Word (.docx)
+ *
+ * @category office
+ * @seedId office_escribir_docx
+ * @spanish crear word, generar docx, escribir documento word, exportar a docx
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const log = logger.child("office-escribir-docx");
+
+interface ParrafoInput {
+  texto: string;
+  tipo?: "titulo1" | "titulo2" | "titulo3" | "parrafo" | "lista";
+  negrita?: boolean;
+  cursiva?: boolean;
+}
+
+interface TablaInput {
+  filas: Array<{ celdas: string[] }>;
+  encabezado?: boolean;
+}
+
+export const officeEscribirDocxTool: Tool = {
+  name: "office_escribir_docx",
+  description:
+    "Generar un archivo Word (.docx) con párrafos, títulos y tablas. Spanish: crear word, generar docx, escribir documento word, exportar a docx",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta donde guardar el archivo .docx generado",
+      },
+      titulo: {
+        type: "string",
+        description: "Título del documento (opcional)",
+      },
+      parrafos: {
+        type: "array",
+        description:
+          "Array de párrafos a incluir. Cada párrafo tiene: texto (string), tipo ('titulo1'|'titulo2'|'titulo3'|'parrafo'|'lista'), negrita (bool), cursiva (bool)",
+        items: {
+          type: "object",
+          properties: {
+            texto: { type: "string" },
+            tipo: { type: "string" },
+            negrita: { type: "boolean" },
+            cursiva: { type: "boolean" },
+          },
+        },
+      },
+      tablas: {
+        type: "array",
+        description:
+          "Array de tablas a incluir. Cada tabla tiene: filas (array de {celdas: string[]}), encabezado (bool, primera fila como encabezado)",
+        items: {
+          type: "object",
+          properties: {
+            filas: { type: "array", items: { type: "object" } },
+            encabezado: { type: "boolean" },
+          },
+        },
+      },
+    },
+    required: ["ruta"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const titulo = params.titulo as string | undefined;
+    const parrafosInput = (params.parrafos as ParrafoInput[]) ?? [];
+    const tablasInput = (params.tablas as TablaInput[]) ?? [];
+
+    log.debug(`Generando DOCX: ${ruta}`);
+
+    try {
+      const {
+        Document,
+        Packer,
+        Paragraph,
+        TextRun,
+        HeadingLevel,
+        Table,
+        TableRow,
+        TableCell,
+        WidthType,
+        BorderStyle,
+      } = await import("docx");
+
+      const seccionChildren: any[] = [];
+
+      // Título del documento
+      if (titulo) {
+        seccionChildren.push(
+          new Paragraph({
+            text: titulo,
+            heading: HeadingLevel.TITLE,
+          })
+        );
+      }
+
+      // Párrafos
+      for (const p of parrafosInput) {
+        const run = new TextRun({
+          text: p.texto,
+          bold: p.negrita ?? false,
+          italics: p.cursiva ?? false,
+        });
+
+        let heading: any = undefined;
+        if (p.tipo === "titulo1") heading = HeadingLevel.HEADING_1;
+        else if (p.tipo === "titulo2") heading = HeadingLevel.HEADING_2;
+        else if (p.tipo === "titulo3") heading = HeadingLevel.HEADING_3;
+
+        const opciones: any = { children: [run] };
+        if (heading) opciones.heading = heading;
+        if (p.tipo === "lista") opciones.bullet = { level: 0 };
+
+        seccionChildren.push(new Paragraph(opciones));
+      }
+
+      // Tablas
+      for (const tablaInput of tablasInput) {
+        const filas = tablaInput.filas.map((fila, filaIdx) => {
+          const celdas = fila.celdas.map((textoCelda) => {
+            const esEncabezado = tablaInput.encabezado && filaIdx === 0;
+            return new TableCell({
+              children: [
+                new Paragraph({
+                  children: [
+                    new TextRun({
+                      text: textoCelda,
+                      bold: esEncabezado,
+                    }),
+                  ],
+                }),
+              ],
+            });
+          });
+          return new TableRow({ children: celdas });
+        });
+
+        seccionChildren.push(
+          new Table({
+            rows: filas,
+            width: { size: 100, type: WidthType.PERCENTAGE },
+          })
+        );
+
+        // Línea en blanco después de la tabla
+        seccionChildren.push(new Paragraph({ text: "" }));
+      }
+
+      const doc = new Document({
+        sections: [
+          {
+            children: seccionChildren,
+          },
+        ],
+      });
+
+      const rutaAbsoluta = path.resolve(ruta);
+      const dirDestino = path.dirname(rutaAbsoluta);
+      if (!fs.existsSync(dirDestino)) {
+        fs.mkdirSync(dirDestino, { recursive: true });
+      }
+
+      const buffer = await Packer.toBuffer(doc);
+      fs.writeFileSync(rutaAbsoluta, buffer);
+
+      log.info(`DOCX generado: ${rutaAbsoluta} (${buffer.length} bytes)`);
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        bytesEscritos: buffer.length,
+        parrafos: parrafosInput.length,
+        tablas: tablasInput.length,
+      };
+    } catch (error) {
+      log.error(`Error generando DOCX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo generar el archivo DOCX: ${(error as Error).message}`,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,172 @@
+/**
+ * office_escribir_pdf - Generar un archivo PDF desde texto
+ *
+ * @category office
+ * @seedId office_escribir_pdf
+ * @spanish crear pdf, generar pdf, escribir pdf, exportar a pdf
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const log = logger.child("office-escribir-pdf");
+
+export const officeEscribirPdfTool: Tool = {
+  name: "office_escribir_pdf",
+  description:
+    "Generar un archivo PDF desde texto con configuración de márgenes y tamaño de página. Spanish: crear pdf, generar pdf, escribir pdf, exportar a pdf",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta donde guardar el archivo PDF generado",
+      },
+      contenido: {
+        type: "string",
+        description: "Texto o contenido a escribir en el PDF",
+      },
+      titulo: {
+        type: "string",
+        description: "Título del documento (opcional)",
+      },
+      tamaño_pagina: {
+        type: "string",
+        description: "Tamaño de página: 'A4' o 'Letter' (default: 'A4')",
+        enum: ["A4", "Letter"],
+      },
+      margen: {
+        type: "number",
+        description: "Margen en puntos (default: 50)",
+      },
+      tamaño_fuente: {
+        type: "number",
+        description: "Tamaño de fuente en puntos (default: 12)",
+      },
+    },
+    required: ["ruta", "contenido"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const contenido = params.contenido as string;
+    const titulo = params.titulo as string | undefined;
+    const tamañoPagina = (params.tamaño_pagina as string) ?? "A4";
+    const margen = (params.margen as number) ?? 50;
+    const tamañoFuente = (params.tamaño_fuente as number) ?? 12;
+
+    log.debug(`Generando PDF: ${ruta}`);
+
+    try {
+      const { PDFDocument, StandardFonts, rgb, PageSizes } = await import("pdf-lib");
+
+      const pdfDoc = await PDFDocument.create();
+
+      if (titulo) {
+        pdfDoc.setTitle(titulo);
+      }
+      pdfDoc.setCreator("Hive Agent");
+      pdfDoc.setCreationDate(new Date());
+
+      const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+      const pageSize = tamañoPagina === "Letter" ? PageSizes.Letter : PageSizes.A4;
+
+      const anchoPagina = pageSize[0];
+      const altoPagina = pageSize[1];
+      const anchoUtil = anchoPagina - margen * 2;
+      const lineHeight = tamañoFuente * 1.4;
+
+      // Si hay título, agregarlo primero
+      const lineasTodas: string[] = [];
+      if (titulo) {
+        lineasTodas.push(titulo);
+        lineasTodas.push(""); // línea en blanco
+      }
+
+      // Dividir el contenido en líneas respetando saltos de línea
+      const lineasContenido = contenido.split("\n");
+
+      // Para cada línea, dividir en sublíneas si es demasiado larga
+      for (const linea of lineasContenido) {
+        if (linea.trim() === "") {
+          lineasTodas.push("");
+          continue;
+        }
+
+        const palabras = linea.split(" ");
+        let lineaActual = "";
+
+        for (const palabra of palabras) {
+          const prueba = lineaActual ? `${lineaActual} ${palabra}` : palabra;
+          const ancho = font.widthOfTextAtSize(prueba, tamañoFuente);
+
+          if (ancho > anchoUtil && lineaActual) {
+            lineasTodas.push(lineaActual);
+            lineaActual = palabra;
+          } else {
+            lineaActual = prueba;
+          }
+        }
+
+        if (lineaActual) {
+          lineasTodas.push(lineaActual);
+        }
+      }
+
+      // Distribuir líneas en páginas
+      const lineasPorPagina = Math.floor((altoPagina - margen * 2) / lineHeight);
+      let paginaActual = pdfDoc.addPage(pageSize);
+      let yActual = altoPagina - margen;
+      let lineasEnPagina = 0;
+
+      for (let i = 0; i < lineasTodas.length; i++) {
+        if (lineasEnPagina >= lineasPorPagina) {
+          paginaActual = pdfDoc.addPage(pageSize);
+          yActual = altoPagina - margen;
+          lineasEnPagina = 0;
+        }
+
+        const esEncabezado = titulo && i === 0;
+        const fuenteActual = esEncabezado ? tamañoFuente + 4 : tamañoFuente;
+
+        if (lineasTodas[i] !== "") {
+          paginaActual.drawText(lineasTodas[i], {
+            x: margen,
+            y: yActual,
+            size: fuenteActual,
+            font,
+            color: rgb(0, 0, 0),
+          });
+        }
+
+        yActual -= lineHeight;
+        lineasEnPagina++;
+      }
+
+      const rutaAbsoluta = path.resolve(ruta);
+      const dirDestino = path.dirname(rutaAbsoluta);
+      if (!fs.existsSync(dirDestino)) {
+        fs.mkdirSync(dirDestino, { recursive: true });
+      }
+
+      const pdfBytes = await pdfDoc.save();
+      fs.writeFileSync(rutaAbsoluta, pdfBytes);
+
+      log.info(`PDF generado: ${rutaAbsoluta} (${pdfDoc.getPageCount()} páginas)`);
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        paginas: pdfDoc.getPageCount(),
+        bytesEscritos: pdfBytes.length,
+      };
+    } catch (error) {
+      log.error(`Error generando PDF: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo generar el PDF: ${(error as Error).message}`,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,174 @@
+/**
+ * office_escribir_pptx - Generar un archivo PowerPoint (.pptx)
+ *
+ * @category office
+ * @seedId office_escribir_pptx
+ * @spanish crear powerpoint, generar pptx, escribir presentacion, exportar a pptx
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const log = logger.child("office-escribir-pptx");
+
+interface DiapositivaInput {
+  titulo?: string;
+  contenido?: string;
+  puntos?: string[];
+  notas?: string;
+}
+
+export const officeEscribirPptxTool: Tool = {
+  name: "office_escribir_pptx",
+  description:
+    "Generar un archivo PowerPoint (.pptx) desde un array de diapositivas con título y contenido. Spanish: crear powerpoint, generar pptx, escribir presentacion, exportar a pptx",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta donde guardar el archivo .pptx generado",
+      },
+      titulo_presentacion: {
+        type: "string",
+        description: "Título de la presentación (aparece en la primera diapositiva)",
+      },
+      diapositivas: {
+        type: "array",
+        description:
+          "Array de diapositivas. Cada una tiene: titulo (string), contenido (string, texto libre), puntos (string[], lista de viñetas), notas (string, notas del presentador)",
+        items: {
+          type: "object",
+          properties: {
+            titulo: { type: "string" },
+            contenido: { type: "string" },
+            puntos: { type: "array", items: { type: "string" } },
+            notas: { type: "string" },
+          },
+        },
+      },
+    },
+    required: ["ruta", "diapositivas"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const tituloPresentacion = params.titulo_presentacion as string | undefined;
+    const diapositivasInput = params.diapositivas as DiapositivaInput[];
+
+    log.debug(`Generando PPTX: ${ruta}`);
+
+    try {
+      const pptxgen = (await import("pptxgenjs")).default;
+      const pres = new pptxgen();
+
+      // Configuración básica
+      pres.layout = "LAYOUT_16x9";
+
+      // Diapositiva de título (si se proporciona título de presentación)
+      if (tituloPresentacion) {
+        const slidePortada = pres.addSlide();
+        slidePortada.addText(tituloPresentacion, {
+          x: "10%",
+          y: "35%",
+          w: "80%",
+          h: "30%",
+          fontSize: 36,
+          bold: true,
+          align: "center",
+          color: "363636",
+        });
+      }
+
+      // Diapositivas de contenido
+      for (const diapoInput of diapositivasInput) {
+        const slide = pres.addSlide();
+
+        // Título de la diapositiva
+        if (diapoInput.titulo) {
+          slide.addText(diapoInput.titulo, {
+            x: "5%",
+            y: "5%",
+            w: "90%",
+            h: "15%",
+            fontSize: 24,
+            bold: true,
+            color: "363636",
+            valign: "middle",
+          });
+        }
+
+        const yContenido = diapoInput.titulo ? "22%" : "10%";
+        const hContenido = diapoInput.titulo ? "70%" : "82%";
+
+        // Puntos de viñeta (tienen prioridad sobre contenido libre)
+        if (diapoInput.puntos && diapoInput.puntos.length > 0) {
+          const textoPuntos = diapoInput.puntos.map((punto) => ({
+            text: punto,
+            options: {
+              bullet: true,
+              fontSize: 18,
+              color: "595959",
+              breakLine: true,
+            } as any,
+          }));
+
+          slide.addText(textoPuntos, {
+            x: "5%",
+            y: yContenido,
+            w: "90%",
+            h: hContenido,
+            valign: "top",
+          });
+        } else if (diapoInput.contenido) {
+          // Texto libre
+          slide.addText(diapoInput.contenido, {
+            x: "5%",
+            y: yContenido,
+            w: "90%",
+            h: hContenido,
+            fontSize: 16,
+            color: "595959",
+            valign: "top",
+            wrap: true,
+          });
+        }
+
+        // Notas del presentador
+        if (diapoInput.notas) {
+          slide.addNotes(diapoInput.notas);
+        }
+      }
+
+      const rutaAbsoluta = path.resolve(ruta);
+      const dirDestino = path.dirname(rutaAbsoluta);
+      if (!fs.existsSync(dirDestino)) {
+        fs.mkdirSync(dirDestino, { recursive: true });
+      }
+
+      // Escribir el archivo
+      await pres.writeFile({ fileName: rutaAbsoluta });
+
+      const stats = fs.statSync(rutaAbsoluta);
+
+      log.info(
+        `PPTX generado: ${rutaAbsoluta} (${diapositivasInput.length} diapositivas)`
+      );
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        totalDiapositivas:
+          diapositivasInput.length + (tituloPresentacion ? 1 : 0),
+        bytesEscritos: stats.size,
+      };
+    } catch (error) {
+      log.error(`Error generando PPTX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo generar el archivo PowerPoint: ${(error as Error).message}`,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,116 @@
+/**
+ * office_escribir_xlsx - Generar un archivo Excel (.xlsx)
+ *
+ * @category office
+ * @seedId office_escribir_xlsx
+ * @spanish crear excel, generar xlsx, escribir excel, exportar a xlsx
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const log = logger.child("office-escribir-xlsx");
+
+interface HojaInput {
+  nombre: string;
+  datos: Record<string, any>[] | any[][];
+  encabezados?: string[];
+}
+
+export const officeEscribirXlsxTool: Tool = {
+  name: "office_escribir_xlsx",
+  description:
+    "Generar un archivo Excel (.xlsx) desde un objeto JSON con hojas, filas y columnas. Spanish: crear excel, generar xlsx, escribir excel, exportar a xlsx",
+  parameters: {
+    type: "object",
+    properties: {
+      ruta: {
+        type: "string",
+        description: "Ruta donde guardar el archivo .xlsx generado",
+      },
+      hojas: {
+        type: "array",
+        description:
+          "Array de hojas a crear. Cada hoja tiene: nombre (string), datos (array de objetos o array de arrays), encabezados (string[], opcional para forzar orden de columnas)",
+        items: {
+          type: "object",
+          properties: {
+            nombre: { type: "string" },
+            datos: { type: "array" },
+            encabezados: { type: "array", items: { type: "string" } },
+          },
+        },
+      },
+    },
+    required: ["ruta", "hojas"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const ruta = params.ruta as string;
+    const hojasInput = params.hojas as HojaInput[];
+
+    log.debug(`Generando XLSX: ${ruta}`);
+
+    try {
+      const XLSX = await import("xlsx");
+
+      const workbook = XLSX.utils.book_new();
+
+      for (const hojaInput of hojasInput) {
+        let worksheet: any;
+
+        if (
+          hojasInput.length > 0 &&
+          Array.isArray(hojaInput.datos) &&
+          hojaInput.datos.length > 0 &&
+          Array.isArray(hojaInput.datos[0])
+        ) {
+          // Si los datos son array de arrays
+          worksheet = XLSX.utils.aoa_to_sheet(hojaInput.datos as any[][]);
+        } else {
+          // Si los datos son array de objetos
+          worksheet = XLSX.utils.json_to_sheet(
+            hojaInput.datos as Record<string, any>[],
+            hojaInput.encabezados ? { header: hojaInput.encabezados } : undefined
+          );
+        }
+
+        XLSX.utils.book_append_sheet(workbook, worksheet, hojaInput.nombre);
+      }
+
+      const rutaAbsoluta = path.resolve(ruta);
+      const dirDestino = path.dirname(rutaAbsoluta);
+      if (!fs.existsSync(dirDestino)) {
+        fs.mkdirSync(dirDestino, { recursive: true });
+      }
+
+      const buffer = XLSX.write(workbook, { type: "buffer", bookType: "xlsx" });
+      fs.writeFileSync(rutaAbsoluta, buffer);
+
+      const totalFilas = hojasInput.reduce(
+        (acc, h) => acc + h.datos.length,
+        0
+      );
+
+      log.info(
+        `XLSX generado: ${rutaAbsoluta} (${hojasInput.length} hojas, ${totalFilas} filas)`
+      );
+
+      return {
+        ok: true,
+        ruta: rutaAbsoluta,
+        hojas: hojasInput.map((h) => h.nombre),
+        totalHojas: hojasInput.length,
+        totalFilas,
+        bytesEscritos: buffer.length,
+      };
+    } catch (error) {
+      log.error(`Error generando XLSX: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `No se pudo generar el archivo Excel: ${(error as Error).message}`,
+      };
+    }
+  },
+};