@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/processors/document/OpenDocumentProcessor.js

@@ -1,212 +0,0 @@
-/**
- * OpenDocument Processor
- *
- * Processes OpenDocument format files (.odt, .ods, .odp) by extracting
- * text content from the internal XML structure.
- *
- * @module processors/document/OpenDocumentProcessor
- */
-import { createRequire } from "node:module";
-import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
-import { SIZE_LIMITS } from "../config/index.js";
-const require = createRequire(import.meta.url);
-/**
- * OpenDocument Processor - handles .odt, .ods, .odp files
- *
- * OpenDocument files are ZIP archives containing XML content.
- * The main content is in content.xml within the archive.
- *
- * Priority: ~105 (between Word and Text)
- */
-export class OpenDocumentProcessor extends BaseFileProcessor {
-    constructor() {
-        super({
-            maxSizeMB: SIZE_LIMITS.DOCUMENT_MAX_MB,
-            timeoutMs: 60000,
-            supportedMimeTypes: [
-                "application/vnd.oasis.opendocument.text",
-                "application/vnd.oasis.opendocument.spreadsheet",
-                "application/vnd.oasis.opendocument.presentation",
-            ],
-            supportedExtensions: [".odt", ".ods", ".odp"],
-            fileTypeName: "OpenDocument",
-            defaultFilename: "document.odt",
-        });
-    }
-    /**
-     * Validate that the file is a valid ZIP archive (OpenDocument format)
-     */
-    async validateDownloadedFile(buffer, _fileInfo) {
-        if (buffer.length < 4) {
-            return "File too small to be a valid OpenDocument file";
-        }
-        // Check for PK (ZIP) signature
-        const signature = buffer.subarray(0, 2).toString("ascii");
-        if (signature !== "PK") {
-            return "Invalid OpenDocument format - not a valid ZIP archive";
-        }
-        return null;
-    }
-    /**
-     * Build the processed result by extracting content from the OpenDocument
-     */
-    buildProcessedResult(buffer, fileInfo) {
-        const ext = this.getExtension(fileInfo.name);
-        const format = this.detectFormat(ext);
-        let textContent;
-        let paragraphCount;
-        let truncated = false;
-        try {
-            // Dynamically import adm-zip to avoid issues if not available
-            const AdmZip = require("adm-zip");
-            const zip = new AdmZip(buffer);
-            // Try to get content.xml
-            const contentEntry = zip.getEntry("content.xml");
-            if (contentEntry) {
-                const xmlContent = contentEntry.getData().toString("utf-8");
-                const extracted = this.extractTextFromXml(xmlContent);
-                textContent = extracted.text;
-                paragraphCount = extracted.paragraphCount;
-                // Check for truncation
-                const maxChars = 500000; // ~500KB of text
-                if (textContent.length > maxChars) {
-                    textContent =
-                        textContent.substring(0, maxChars) + "\n\n... [Content truncated]";
-                    truncated = true;
-                }
-            }
-            else {
-                throw new Error("content.xml not found in OpenDocument archive");
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Unknown error";
-            throw new Error(`Failed to extract OpenDocument content: ${message}`, {
-                cause: error,
-            });
-        }
-        return {
-            textContent,
-            format,
-            paragraphCount,
-            truncated,
-            buffer,
-            mimetype: fileInfo.mimetype || "application/vnd.oasis.opendocument.text",
-            size: fileInfo.size,
-            filename: this.getFilename(fileInfo),
-        };
-    }
-    /**
-     * Decode HTML entities in a single pass to prevent double-unescaping.
-     * Sequential replacement is vulnerable: "&amp;lt;" → "&lt;" → "<"
-     * Single-pass avoids this by replacing each entity exactly once.
-     */
-    decodeHtmlEntities(text) {
-        const entityMap = {
-            "&amp;": "&",
-            "&lt;": "<",
-            "&gt;": ">",
-            "&quot;": '"',
-            "&apos;": "'",
-        };
-        return text.replace(/&(?:amp|lt|gt|quot|apos);/g, (match) => entityMap[match] ?? match);
-    }
-    /**
-     * Extract text content from OpenDocument XML
-     */
-    extractTextFromXml(xml) {
-        const paragraphs = [];
-        // Extract text from <text:p> elements (paragraphs)
-        // Also handle <text:h> (headings) and <text:span> (spans)
-        const textPattern = /<text:(?:p|h|span)[^>]*>([\s\S]*?)<\/text:(?:p|h|span)>/gi;
-        const matches = xml.matchAll(textPattern);
-        for (const match of matches) {
-            // Remove nested tags iteratively to handle fragments like "<scr<script>ipt>"
-            let stripped = match[1];
-            let prev;
-            do {
-                prev = stripped;
-                stripped = stripped.replace(/<[^>]+>/g, "");
-            } while (stripped !== prev);
-            const text = this.decodeHtmlEntities(stripped).trim();
-            if (text) {
-                paragraphs.push(text);
-            }
-        }
-        // Also try a simpler approach for spreadsheets and presentations
-        // where content might be in different structures
-        if (paragraphs.length === 0) {
-            // Try to extract any text content between tags (iterative to handle nested fragments)
-            let stripped = xml;
-            let prev;
-            do {
-                prev = stripped;
-                stripped = stripped.replace(/<[^>]+>/g, " ");
-            } while (stripped !== prev);
-            const simpleText = this.decodeHtmlEntities(stripped.replace(/\s+/g, " ")).trim();
-            if (simpleText) {
-                paragraphs.push(simpleText);
-            }
-        }
-        return {
-            text: paragraphs.join("\n\n"),
-            paragraphCount: paragraphs.length,
-        };
-    }
-    /**
-     * Detect the OpenDocument format from file extension
-     */
-    detectFormat(ext) {
-        switch (ext?.toLowerCase()) {
-            case ".odt":
-                return "odt";
-            case ".ods":
-                return "ods";
-            case ".odp":
-                return "odp";
-            default:
-                return "unknown";
-        }
-    }
-    /**
-     * Get file extension from filename
-     */
-    getExtension(filename) {
-        const match = filename.toLowerCase().match(/\.[^.]+$/);
-        return match ? match[0] : null;
-    }
-}
-// =============================================================================
-// SINGLETON INSTANCE
-// =============================================================================
-/**
- * Singleton instance of OpenDocumentProcessor
- */
-export const openDocumentProcessor = new OpenDocumentProcessor();
-// =============================================================================
-// HELPER FUNCTIONS
-// =============================================================================
-/**
- * Check if a file is an OpenDocument file by MIME type or extension
- */
-export function isOpenDocumentFile(mimetype, filename) {
-    return openDocumentProcessor.isFileSupported(mimetype, filename);
-}
-/**
- * Validate OpenDocument file size against limits
- */
-export function validateOpenDocumentSize(sizeBytes) {
-    return sizeBytes <= SIZE_LIMITS.DOCUMENT_MAX_MB * 1024 * 1024;
-}
-/**
- * Process an OpenDocument file
- */
-export async function processOpenDocument(fileInfo, options) {
-    return openDocumentProcessor.processFile(fileInfo, options);
-}
-/**
- * Get the maximum allowed OpenDocument file size in MB
- */
-export function getOpenDocumentMaxSizeMB() {
-    return SIZE_LIMITS.DOCUMENT_MAX_MB;
-}

package/dist/client/processors/document/PptxProcessor.js

@@ -1,157 +0,0 @@
-/**
- * PowerPoint (PPTX) Processing Utility
- *
- * Extracts text content from PowerPoint (.pptx) files by treating them
- * as ZIP archives and parsing the slide XML files within.
- *
- * PPTX files are ZIP archives containing:
- * - ppt/slides/slide1.xml, slide2.xml, ... — slide content
- * - ppt/slideMasters/ — master slide templates
- * - ppt/slideLayouts/ — slide layout definitions
- *
- * Text is extracted from `<a:t>` elements in the slide XML files.
- * Slides are sorted by number and presented in reading order.
- *
- * Uses `adm-zip` (already a project dependency) for ZIP extraction.
- *
- * @module processors/document/PptxProcessor
- *
- * @example
- * ```typescript
- * import { PptxProcessor } from "./PptxProcessor.js";
- *
- * const text = await PptxProcessor.extractText(buffer);
- * if (text) {
- *   console.log("Extracted text:", text);
- * }
- * ```
- */
-import AdmZip from "adm-zip";
-/**
- * Regex to match text content within PowerPoint XML `<a:t>` elements.
- * These elements contain the actual visible text on slides.
- */
-const TEXT_ELEMENT_REGEX = /<a:t[^>]*>([\s\S]*?)<\/a:t>/g;
-/**
- * Regex to match slide filenames and extract slide number.
- * Matches entries like "ppt/slides/slide1.xml", "ppt/slides/slide12.xml".
- */
-const SLIDE_ENTRY_REGEX = /^ppt\/slides\/slide(\d+)\.xml$/;
-/**
- * Static utility class for extracting text from PPTX files.
- *
- * Designed as a static class (not extending BaseFileProcessor) because
- * PPTX processing is straightforward ZIP+XML extraction and does not
- * need the full download/validate/process pipeline of BaseFileProcessor.
- */
-export class PptxProcessor {
-    /**
-     * Extract all text content from a PPTX buffer.
-     *
-     * @param content - Raw PPTX file buffer
-     * @returns Formatted text content with slide headers, or null if no text found
-     * @throws Error if the buffer is not a valid ZIP/PPTX file
-     */
-    static async extractText(content) {
-        const zip = new AdmZip(content);
-        const entries = zip.getEntries();
-        // Collect slide entries with their slide numbers for sorting
-        const slides = [];
-        for (const entry of entries) {
-            const match = entry.entryName.match(SLIDE_ENTRY_REGEX);
-            if (match) {
-                const slideNumber = parseInt(match[1], 10);
-                const xmlContent = entry.getData().toString("utf-8");
-                slides.push({ slideNumber, xml: xmlContent });
-            }
-        }
-        // Sort slides by number (slide1, slide2, ...)
-        slides.sort((a, b) => a.slideNumber - b.slideNumber);
-        if (slides.length === 0) {
-            return null;
-        }
-        const parts = [];
-        parts.push(`Presentation: ${slides.length} slide(s)\n`);
-        for (const slide of slides) {
-            const texts = PptxProcessor.extractTextFromXml(slide.xml);
-            if (texts.length > 0) {
-                parts.push(`### Slide ${slide.slideNumber}`);
-                parts.push(texts.join("\n"));
-                parts.push(""); // blank line between slides
-            }
-        }
-        const result = parts.join("\n").trim();
-        return result || null;
-    }
-    /**
-     * Extract text strings from a slide XML document.
-     * Finds all `<a:t>` elements and returns their text content.
-     *
-     * @param xml - Raw XML string from a slide file
-     * @returns Array of text strings found in the slide
-     */
-    static extractTextFromXml(xml) {
-        const texts = [];
-        // Reset regex state for re-entrant usage
-        TEXT_ELEMENT_REGEX.lastIndex = 0;
-        for (let match = TEXT_ELEMENT_REGEX.exec(xml); match !== null; match = TEXT_ELEMENT_REGEX.exec(xml)) {
-            const text = match[1].trim();
-            if (text) {
-                texts.push(text);
-            }
-        }
-        return texts;
-    }
-    // ===========================================================================
-    // TARGETED EXTRACTION API
-    // ===========================================================================
-    /**
-     * Extract text from specific slides in a PPTX file.
-     *
-     * Called by the `extract_file_content` tool for targeted slide access.
-     *
-     * @param content - Raw PPTX file buffer
-     * @param slideNumbers - Array of 1-indexed slide numbers to extract
-     * @returns Formatted text from the requested slides
-     */
-    static async extractSlides(content, slideNumbers) {
-        const zip = new AdmZip(content);
-        const entries = zip.getEntries();
-        // Collect all slides
-        const slides = [];
-        for (const entry of entries) {
-            const match = entry.entryName.match(SLIDE_ENTRY_REGEX);
-            if (match) {
-                const slideNumber = parseInt(match[1], 10);
-                if (slideNumbers.includes(slideNumber)) {
-                    const xmlContent = entry.getData().toString("utf-8");
-                    slides.push({ slideNumber, xml: xmlContent });
-                }
-            }
-        }
-        slides.sort((a, b) => a.slideNumber - b.slideNumber);
-        if (slides.length === 0) {
-            // List total slides to help the LLM
-            let totalSlides = 0;
-            for (const entry of entries) {
-                if (SLIDE_ENTRY_REGEX.test(entry.entryName)) {
-                    totalSlides++;
-                }
-            }
-            return `Slides ${slideNumbers.join(", ")} not found. This presentation has ${totalSlides} slide(s).`;
-        }
-        const parts = [];
-        for (const slide of slides) {
-            const texts = PptxProcessor.extractTextFromXml(slide.xml);
-            parts.push(`### Slide ${slide.slideNumber}`);
-            if (texts.length > 0) {
-                parts.push(texts.join("\n"));
-            }
-            else {
-                parts.push("(No text content on this slide)");
-            }
-            parts.push("");
-        }
-        return parts.join("\n").trim();
-    }
-}