@minded-ai/mindedjs 3.0.8-beta.12 → 3.1.9-beta.1

package/src/internalTools/documentExtraction/parseDocumentLocal.ts

@@ -0,0 +1,660 @@
+import os from 'os';
+import path from 'path';
+import fsp from 'fs/promises';
+import { logger } from '../../utils/logger';
+
+export async function parseDocumentWithLocalService({
+  documentSource,
+  isDocumentUrl,
+  sessionId,
+  llamaCloudApiKey,
+  useBase64,
+}: {
+  isDocumentUrl: boolean;
+  documentSource: string;
+  sessionId: string;
+  llamaCloudApiKey?: string;
+  useBase64?: boolean;
+}) {
+  logger.info({
+    msg: '[DocumentParser] Parsing document locally',
+    sessionId,
+    documentSource,
+    sourceType: isDocumentUrl ? 'url' : 'path',
+  });
+
+  const startTime = Date.now();
+
+  try {
+    // Determine document source and content
+    const { content, fileType, fileSize } = await getDocumentContent({ documentSource, isDocumentUrl, sessionId });
+
+    // Process document content based on type
+    let processedContent: string;
+
+    if (isImageFile(fileType)) {
+      processedContent = await processImageDocument({
+        content,
+        llamaCloudApiKey,
+        fileType,
+        filePath: isDocumentUrl ? undefined : documentSource,
+        useBase64,
+        sessionId,
+      });
+    } else {
+      processedContent = await processTextDocument({
+        content,
+        llamaCloudApiKey,
+        fileType,
+        filePath: isDocumentUrl ? undefined : documentSource,
+        sessionId,
+      });
+    }
+
+    logger.info({
+      msg: '[DocumentParser] Document content processed',
+      sessionId,
+      fileType,
+      contentLength: processedContent.length,
+    });
+
+    const processingTime = Date.now() - startTime;
+
+    return {
+      rawContent: processedContent,
+      metadata: {
+        fileSize,
+        fileType,
+        processingTime,
+        contentLength: processedContent.length,
+      },
+    };
+  } catch (err) {
+    logger.error({
+      message: '[DocumentParser] Document processing failed',
+      sessionId,
+      err,
+    });
+    throw new Error(`Document processing failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+async function getDocumentContent({
+  documentSource,
+  isDocumentUrl,
+  sessionId,
+}: {
+  isDocumentUrl: boolean;
+  documentSource: string;
+  sessionId: string;
+}): Promise<{
+  content: Buffer;
+  fileType: string;
+  fileSize?: number;
+}> {
+  // Load the document from URL
+  if (isDocumentUrl) {
+    return fetchDocumentFromUrl({ documentSource, sessionId });
+  }
+  return loadDocumentFromFile({ documentSource, sessionId });
+}
+
+async function fetchDocumentFromUrl({ documentSource, sessionId }: { documentSource: string; sessionId: string }): Promise<{
+  content: Buffer;
+  fileType: string;
+  fileSize?: number;
+}> {
+  logger.debug({
+    msg: '[DocumentParser] Fetching document from URL',
+    sessionId,
+    documentSource,
+  });
+
+  const response = await fetch(documentSource);
+
+  logger.debug({
+    msg: '[DocumentParser] Document fetched from URL',
+    sessionId,
+    documentSource,
+    status: response.status,
+    ok: response.ok,
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch document from URL: ${response.statusText}`);
+  }
+
+  const arrayBuffer = await response.arrayBuffer();
+  const content = Buffer.from(arrayBuffer);
+  const fileType = inferFileTypeFromUrl(documentSource) || inferFileTypeFromBuffer(content);
+
+  logger.debug({
+    msg: '[DocumentParser] Successfully fetched document from URL',
+    sessionId,
+    documentSource,
+    contentSize: content.length,
+    fileType,
+  });
+
+  return {
+    content,
+    fileType,
+    fileSize: content.length,
+  };
+}
+
+async function loadDocumentFromFile({ documentSource, sessionId }: { documentSource: string; sessionId: string }): Promise<{
+  content: Buffer;
+  fileType: string;
+  fileSize?: number;
+}> {
+  logger.debug({
+    msg: '[DocumentParser] Loading document from file',
+    sessionId,
+    documentSource,
+  });
+
+  // Check that the document file exists
+  try {
+    await fsp.access(documentSource)
+  } catch {
+    throw new Error(`Document not found: ${documentSource}`);
+  }
+
+  const content = await fsp.readFile(documentSource);
+  const fileType = path.extname(documentSource).toLowerCase();
+
+  logger.debug({
+    msg: '[DocumentParser] Document loaded from file',
+    sessionId,
+    documentSource,
+    contentSize: content.length,
+    fileType,
+  });
+
+  return {
+    content,
+    fileType,
+    fileSize: content.length,
+  };
+}
+
+/**
+ * Process image documents by converting them to a standardized format
+ */
+async function processImageDocument({
+  content,
+  llamaCloudApiKey,
+  filePath,
+  fileType,
+  useBase64,
+  sessionId,
+}: {
+  content: Buffer;
+  llamaCloudApiKey?: string;
+  filePath?: string;
+  fileType: string;
+  useBase64?: boolean;
+  sessionId: string;
+}): Promise<string> {
+  try {
+    // First, try to use LlamaParser if available for text extraction
+    if (filePath && llamaCloudApiKey) {
+      logger.debug({
+        msg: '[DocumentParser] Calling parseWithLlamaCloud for image',
+        sessionId,
+        filePath,
+      });
+      const parsedContent = await parseWithLlamaCloud({ filePath, llamaCloudApiKey, sessionId });
+      logger.debug({
+        msg: '[DocumentParser] parseWithLlamaCloud returned for image',
+        sessionId,
+        hasContent: !!parsedContent,
+        contentLength: parsedContent?.length,
+      });
+      if (parsedContent) {
+        return parsedContent;
+      }
+    }
+
+    // If no file path, create a temporary file for LlamaCloud parsing
+    if (!filePath && llamaCloudApiKey) {
+      const tempDir = os.tmpdir();
+      const tempFileName = `temp_${Date.now()}${fileType}`;
+      const tempFilePath = path.join(tempDir, tempFileName);
+
+      logger.debug({
+        msg: '[DocumentParser] Creating temp file for image',
+        sessionId,
+        tempFilePath,
+        contentSize: content.length,
+      });
+
+      try {
+        await fsp.writeFile(tempFilePath, content);
+        logger.debug({
+          msg: '[DocumentParser] Calling parseWithLlamaCloud for temp image',
+          sessionId,
+          tempFilePath,
+        });
+        const parsedContent = await parseWithLlamaCloud({ filePath: tempFilePath, llamaCloudApiKey, sessionId });
+        logger.debug({
+          msg: '[DocumentParser] parseWithLlamaCloud returned for temp image',
+          sessionId,
+          hasContent: !!parsedContent,
+          contentLength: parsedContent?.length,
+        });
+        await fsp.unlink(tempFilePath);
+
+        if (parsedContent) {
+          return parsedContent;
+        }
+      } catch (err) {
+        // Clean up temp file on error
+        try {
+          await fsp.access(tempFilePath);
+          await fsp.unlink(tempFilePath);
+        } catch {
+          // pass
+        }
+        logger.warn({
+          msg: '[DocumentParser] Failed to parse image with LlamaCloud',
+          sessionId,
+          err,
+        });
+      }
+    }
+
+    logger.warn({
+      msg: '[DocumentParser] Sharp module not available. Using original image without optimization.',
+      sessionId,
+      fileType,
+      contentSize: content.length,
+    });
+
+    // If sharp is not available, use the original image
+    if (useBase64) {
+      // Return original image as base64
+      const base64Image = content.toString('base64');
+      const mimeType = getMimeType(fileType);
+      return `data:${mimeType};base64,${base64Image}`;
+    } else {
+      // Without sharp and without base64, we cannot process the image
+      return `[IMAGE CONTENT - ${fileType.toUpperCase()} file. Size: ${
+        content.length
+      } bytes. Consider using LLAMA_CLOUD_API_KEY for text extraction or set useBase64: true]`;
+    }
+  } catch (err) {
+    throw new Error(`Failed to process image document: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+/**
+ * Process text-based documents using LlamaParser or fallback methods
+ */
+async function processTextDocument({
+  content,
+  llamaCloudApiKey,
+  filePath,
+  fileType,
+  sessionId,
+}: {
+  content: Buffer | string;
+  llamaCloudApiKey?: string;
+  filePath?: string;
+  fileType?: string;
+  sessionId: string;
+}): Promise<string> {
+  // Try LlamaCloud parsing if we have a file path
+  if (filePath && llamaCloudApiKey) {
+    const parsedContent = await parseWithLlamaCloud({ filePath, llamaCloudApiKey, sessionId });
+    if (parsedContent) {
+      return parsedContent;
+    }
+  }
+
+  // If no file path but we have content and LlamaCloud API key, create a temp file
+  if (!filePath && llamaCloudApiKey && Buffer.isBuffer(content)) {
+    const tempDir = os.tmpdir();
+    const tempFileName = `temp_${Date.now()}${fileType || '.txt'}`;
+    const tempFilePath = path.join(tempDir, tempFileName);
+
+    try {
+      await fsp.writeFile(tempFilePath, content);
+      const parsedContent = await parseWithLlamaCloud({ filePath: tempFilePath, llamaCloudApiKey, sessionId });
+      await fsp.unlink(tempFilePath);
+
+      if (parsedContent) {
+        return parsedContent;
+      }
+    } catch (err) {
+      // Clean up temp file on error
+      try {
+        await fsp.access(tempFilePath);
+        await fsp.unlink(tempFilePath);
+      } catch {
+        // pass
+      }
+      logger.warn({
+        msg: '[DocumentParser] Failed to parse text document with LlamaCloud',
+        sessionId,
+        err,
+      });
+    }
+  }
+
+  // Fallback: handle based on a file type
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  // Basic text extraction for simple formats
+  if (['.txt', '.md', '.html', '.htm', '.xml', '.csv'].includes(fileType || '')) {
+    return content.toString('utf-8');
+  }
+
+  // For unsupported binary formats without LlamaParser
+  throw new Error(`Unsupported document type ${fileType}. Please provide LLAMA_CLOUD_API_KEY for advanced document processing.`);
+}
+
+/**
+ * Parse document using LlamaCloud REST API
+ */
+async function parseWithLlamaCloud({
+  filePath,
+  llamaCloudApiKey,
+  sessionId,
+}: {
+  filePath: string;
+  llamaCloudApiKey: string;
+  sessionId: string;
+}): Promise<string | null> {
+  try {
+    // Step 1: Upload file and start parsing
+    const fileContent = await fsp.readFile(filePath);
+    const fileName = path.basename(filePath);
+    const mimeType = getMimeType(path.extname(filePath));
+
+    const formData = new FormData();
+    const blob = new Blob([new Uint8Array(fileContent)], { type: mimeType });
+    formData.append('file', blob, fileName);
+    formData.append('premium_mode', 'true');
+
+    const uploadResponse = await fetch('https://api.cloud.llamaindex.ai/api/v1/parsing/upload', {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Bearer ${llamaCloudApiKey}`,
+      },
+      body: formData,
+    });
+
+    if (!uploadResponse.ok) {
+      const errorText = await uploadResponse.text();
+      throw new Error(`Failed to upload file: ${uploadResponse.status} - ${errorText}`);
+    }
+
+    const uploadResult = await uploadResponse.json();
+    const jobId = uploadResult.id || uploadResult.job_id;
+
+    if (!jobId) {
+      throw new Error('No job ID returned from upload');
+    }
+
+    logger.info({
+      msg: '[DocumentParser] File uploaded to LlamaCloud',
+      sessionId,
+      jobId,
+      fileName,
+    });
+
+    // Step 2: Poll for job completion
+    let attempts = 0;
+    const maxAttempts = 60; // 60 attempts with 2 second delay = 2 minutes max
+    const pollDelay = 2000; // 2 seconds
+
+    while (attempts < maxAttempts) {
+      const statusResponse = await fetch(`https://api.cloud.llamaindex.ai/api/v1/parsing/job/${jobId}`, {
+        method: 'GET',
+        headers: {
+          Accept: 'application/json',
+          Authorization: `Bearer ${llamaCloudApiKey}`,
+        },
+      });
+
+      if (!statusResponse.ok) {
+        throw new Error(`Failed to check job status: ${statusResponse.status}`);
+      }
+
+      const statusResult = await statusResponse.json();
+      const status = statusResult.status || statusResult.job_status;
+
+      if (status === 'SUCCESS' || status === 'COMPLETED' || status === 'completed') {
+        // Step 3: Retrieve results in Markdown
+
+        // Create an AbortController for timeout
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 20000); // 20 second timeout
+
+        let resultResponse;
+        try {
+          resultResponse = await fetch(`https://api.cloud.llamaindex.ai/api/v1/parsing/job/${jobId}/result/markdown`, {
+            method: 'GET',
+            headers: {
+              Accept: 'application/json',
+              Authorization: `Bearer ${llamaCloudApiKey}`,
+            },
+            signal: controller.signal,
+          });
+        } catch (fetchError) {
+          clearTimeout(timeout);
+          if (fetchError instanceof Error && fetchError.name === 'AbortError') {
+            throw new Error('Timeout fetching results from LlamaCloud after 20 seconds');
+          }
+          throw fetchError;
+        }
+
+        clearTimeout(timeout);
+
+        if (!resultResponse.ok) {
+          const errorText = await resultResponse.text();
+          throw new Error(`Failed to retrieve results: ${resultResponse.status} - ${errorText}`);
+        }
+
+        let resultData: any;
+        try {
+          // Read response using manual stream reading (more reliable than text())
+          let responseText;
+          if (resultResponse.body) {
+            const reader = resultResponse.body.getReader();
+            const chunks: Uint8Array[] = [];
+            let totalLength = 0;
+
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value) {
+                  chunks.push(value);
+                  totalLength += value.length;
+                }
+              }
+
+              // Combine chunks
+              const combined = new Uint8Array(totalLength);
+              let offset = 0;
+              for (const chunk of chunks) {
+                combined.set(chunk, offset);
+                offset += chunk.length;
+              }
+
+              responseText = new TextDecoder().decode(combined);
+            } finally {
+              reader.releaseLock();
+            }
+          } else {
+            responseText = await resultResponse.text();
+          }
+
+          // Try to parse as JSON, but if it fails, use the text directly
+          try {
+            resultData = JSON.parse(responseText);
+          } catch {
+            // If it's not JSON, assume it's the markdown content directly
+            resultData = responseText;
+          }
+        } catch (textError) {
+          logger.error({
+            msg: '[DocumentParser] Failed to read response text',
+            sessionId,
+            jobId,
+            error: textError instanceof Error ? textError.message : String(textError),
+            stack: textError instanceof Error ? textError.stack : undefined,
+          });
+          throw new Error('Failed to read response from LlamaCloud');
+        }
+
+        logger.debug({
+          msg: '[DocumentParser] Result data structure',
+          sessionId,
+          jobId,
+          dataType: typeof resultData,
+          keys: typeof resultData === 'object' && resultData !== null ? Object.keys(resultData) : [],
+          hasMarkdown: typeof resultData === 'object' && 'markdown' in resultData,
+          hasContent: typeof resultData === 'object' && 'content' in resultData,
+          hasText: typeof resultData === 'object' && 'text' in resultData,
+        });
+
+        // The API might return the markdown directly as a string or nested in an object
+        let markdownContent: string;
+        if (typeof resultData === 'string') {
+          markdownContent = resultData;
+        } else {
+          markdownContent = resultData.markdown || resultData.content || resultData.text || '';
+        }
+
+        if (!markdownContent) {
+          logger.error({
+            msg: '[DocumentParser] No content in result',
+            sessionId,
+            jobId,
+            resultData: JSON.stringify(resultData).substring(0, 500),
+          });
+          throw new Error('No content returned from parsing');
+        }
+
+        logger.info({
+          msg: '[DocumentParser] Successfully parsed document with LlamaCloud',
+          sessionId,
+          jobId,
+          contentLength: markdownContent.length,
+          preview: markdownContent.substring(0, 100),
+        });
+
+        logger.debug({
+          msg: '[DocumentParser] About to return markdown content',
+          sessionId,
+          jobId,
+        });
+
+        return markdownContent;
+      } else if (status === 'FAILED' || status === 'ERROR' || status === 'failed') {
+        throw new Error(`Parsing job failed: ${statusResult.error || 'Unknown error'}`);
+      }
+
+      // Wait before next attempt
+      await new Promise((resolve) => setTimeout(resolve, pollDelay));
+      attempts++;
+    }
+
+    throw new Error('Parsing job timed out after 2 minutes');
+  } catch (err) {
+    logger.warn({
+      message: '[DocumentParser] LlamaCloud parsing failed',
+      sessionId,
+      err,
+    });
+    return null;
+  } finally {
+    logger.debug({
+      msg: '[DocumentParser] parseWithLlamaCloud finished',
+      sessionId,
+      filePath,
+    });
+  }
+}
+
+/**
+ * Infer file type from buffer content
+ */
+function inferFileTypeFromBuffer(buffer: Buffer): string {
+  // Check common file signatures
+  const signatures: { [key: string]: string } = {
+    '89504E47': '.png',
+    FFD8FF: '.jpg',
+    '47494638': '.gif',
+    '25504446': '.pdf',
+    '504B0304': '.zip', // Also used by docx, xlsx, pptx
+    D0CF11E0: '.doc', // Also xls, ppt
+  };
+
+  const hex = buffer.toString('hex', 0, 4).toUpperCase();
+
+  for (const [signature, type] of Object.entries(signatures)) {
+    if (hex.startsWith(signature)) {
+      return type;
+    }
+  }
+
+  return '.unknown';
+}
+
+/**
+ * Get MIME type for file extension
+ */
+function getMimeType(fileExtension: string): string {
+  const mimeTypes: { [key: string]: string } = {
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.txt': 'text/plain',
+    '.rtf': 'application/rtf',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.webp': 'image/webp',
+    '.tiff': 'image/tiff',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.csv': 'text/csv',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.xml': 'application/xml',
+    '.md': 'text/markdown',
+  };
+
+  return mimeTypes[fileExtension.toLowerCase()] || 'application/octet-stream';
+}
+
+/**
+ * Infer file type from URL
+ */
+function inferFileTypeFromUrl(url: string): string | null {
+  try {
+    const pathname = new URL(url).pathname;
+    const extension = path.extname(pathname).toLowerCase();
+    return extension || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if file is an image type
+ */
+function isImageFile(fileType: string): boolean {
+  const imageTypes = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff'];
+  return imageTypes.includes(fileType.toLowerCase());
+}