@juspay/neurolink 9.1.1 → 9.3.0

package/dist/lib/processors/index.js

@@ -0,0 +1,113 @@
+/**
+ * File Processors Module
+ *
+ * Comprehensive file processing infrastructure for NeuroLink.
+ * Provides base classes, configuration, error handling, and registry
+ * for building and managing file processors.
+ *
+ * @module processors
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   // Base processor infrastructure
+ *   BaseFileProcessor,
+ *   type FileInfo,
+ *   type FileProcessingResult,
+ *   type ProcessedFileBase,
+ *
+ *   // Configuration
+ *   MIME_TYPES,
+ *   FILE_EXTENSIONS,
+ *   SIZE_LIMITS,
+ *
+ *   // Error handling
+ *   FileErrorCode,
+ *   createFileError,
+ *
+ *   // Registry
+ *   ProcessorRegistry,
+ *   getProcessorRegistry,
+ *   PROCESSOR_PRIORITIES,
+ * } from "./processors/index.js";
+ *
+ * // Create a custom processor
+ * class MyProcessor extends BaseFileProcessor<MyProcessedFile> {
+ *   constructor() {
+ *     super({
+ *       maxSizeMB: 10,
+ *       timeoutMs: 30000,
+ *       supportedMimeTypes: ["application/x-custom"],
+ *       supportedExtensions: [".custom"],
+ *       fileTypeName: "custom",
+ *       defaultFilename: "file.custom",
+ *     });
+ *   }
+ *
+ *   protected buildProcessedResult(buffer: Buffer, fileInfo: FileInfo): MyProcessedFile {
+ *     return {
+ *       buffer,
+ *       mimetype: fileInfo.mimetype,
+ *       size: buffer.length,
+ *       filename: this.getFilename(fileInfo),
+ *     };
+ *   }
+ * }
+ *
+ * // Register with the registry
+ * const registry = getProcessorRegistry();
+ * registry.register({
+ *   name: "custom",
+ *   priority: 100,
+ *   processor: new MyProcessor(),
+ *   isSupported: (mimetype) => mimetype === "application/x-custom",
+ * });
+ * ```
+ */
+// =============================================================================
+// BASE PROCESSOR INFRASTRUCTURE (single source of truth for ALL types)
+// =============================================================================
+export { 
+// Base class
+BaseFileProcessor, 
+// Constants
+DEFAULT_IMAGE_MAX_SIZE_MB, DEFAULT_IMAGE_TIMEOUT_MS, DEFAULT_RETRY_CONFIG, DEFAULT_TEXT_MAX_SIZE_MB, DEFAULT_TEXT_TIMEOUT_MS, 
+// Utility functions
+getDefaultImageMaxSizeMB, getDefaultImageTimeout, getDefaultTextMaxSizeMB, getDefaultTextTimeout, PROCESSOR_PRIORITIES, } from "./base/index.js";
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+export { AI_VISION_EXTENSIONS, ARCHIVE_EXTENSIONS, ARCHIVE_LIMITS, ARCHIVE_MIME_TYPES, AUDIO_EXTENSIONS, AUDIO_MIME_TYPES, bytesToMB, CONFIG_EXTENSIONS, CSV_EXTENSIONS, DATA_EXTENSIONS, DATA_MIME_TYPES, DATABASE_EXTENSIONS, DESIGN_EXTENSIONS, DOCUMENT_EXTENSIONS, DOCUMENT_MIME_TYPES, detectLanguageFromFilename, EXACT_FILENAME_MAP, EXCEL_EXTENSIONS, EXECUTABLE_EXTENSIONS, FILE_EXTENSIONS, formatBytes, getLanguageIdentifier, getSizeLimitForType, getSupportedExtensions, getSupportedFilenames, HTML_EXTENSIONS, IMAGE_EXTENSIONS, IMAGE_MIME_TYPES, isSourceCodeFile, isWithinSizeLimit, JSON_EXTENSIONS, LANGUAGE_MAP, MARKDOWN_EXTENSIONS, MIME_TYPES, mbToBytes, OPENDOCUMENT_EXTENSIONS, PDF_EXTENSIONS, POWERPOINT_EXTENSIONS, PROCESSING_LIMITS, RTF_EXTENSIONS, SIZE_LIMITS, SIZE_LIMITS_BYTES, SIZE_LIMITS_MB, SOURCE_CODE_EXTENSIONS, SOURCE_CODE_MIME_TYPES, TEXT_EXTENSIONS, TEXT_MIME_TYPES, VIDEO_EXTENSIONS, VIDEO_MIME_TYPES, validateFileSize, WORD_EXTENSIONS, XML_EXTENSIONS, YAML_EXTENSIONS, YAML_LIMITS, } from "./config/index.js";
+// =============================================================================
+// ERROR HANDLING (functions and runtime values only — types come from base)
+// =============================================================================
+export { combineSummaries, createCustomFileError, createFileError, createProcessingSummary, ERROR_MESSAGES, extractHttpStatus, extractSafeMetadata, FileErrorCode, formatFileError, generateErrorFingerprint, getErrorTemplate, getRetryDelay, isFileProcessingError, isRetryableError, isRetryableErrorCode, mapErrorToCode, safeStringify, serializeError, summarizeError, } from "./errors/index.js";
+// =============================================================================
+// PROCESSOR REGISTRY (class and registration type only — shared types from base)
+// =============================================================================
+export { getProcessorRegistry, ProcessorRegistry, } from "./registry/index.js";
+// =============================================================================
+// MARKUP PROCESSORS
+// =============================================================================
+export { HtmlProcessor, htmlProcessor, isHtmlFile, isMarkdownFile, isSvgFile, isTextFile, MarkdownProcessor, markdownProcessor, processHtml, processMarkdown, processSvg, processText, SvgProcessor, svgProcessor, TextProcessor, textProcessor, validateHtmlSize, validateMarkdownSize, validateSvgSize, } from "./markup/index.js";
+// =============================================================================
+// CODE PROCESSORS
+// =============================================================================
+export { ConfigProcessor, configProcessor, detectLanguage, isConfigFile, processConfig, processSourceCode, SourceCodeProcessor, sourceCodeProcessor, validateSourceCodeSize, } from "./code/index.js";
+// =============================================================================
+// DATA PROCESSORS
+// =============================================================================
+export { isJsonFile, isXmlFile, isYamlFile, JsonProcessor, jsonProcessor, processJson, processXml, processYaml, validateJsonSize, validateXmlSize, validateYamlSize, XmlProcessor, xmlProcessor, YamlProcessor, yamlProcessor, } from "./data/index.js";
+// =============================================================================
+// DOCUMENT PROCESSORS
+// =============================================================================
+export { ExcelProcessor, excelProcessor, getExcelMaxRows, getExcelMaxSheets, getExcelMaxSizeMB, getOpenDocumentMaxSizeMB, isExcelFile, isOpenDocumentFile, isRtfFile, isWordFile, OpenDocumentProcessor, openDocumentProcessor, processExcel, processOpenDocument, processRtf, processWord, RtfProcessor, rtfProcessor, validateExcelSize, validateOpenDocumentSize, validateRtfSize, validateWordSize, WordProcessor, wordProcessor, } from "./document/index.js";
+// =============================================================================
+// FILE PROCESSOR INTEGRATION
+// =============================================================================
+export { getProcessorForFile, getSupportedFileTypes, isFileTypeSupported, processBatchWithRegistry, processFileWithRegistry, } from "./integration/index.js";
+// =============================================================================
+// CLI HELPERS
+// =============================================================================
+export { detectMimeType, fileExists, getCliUsage, getFileExtension, getSupportedFileTypes as getCliSupportedFileTypes, listSupportedFileTypes, loadFileFromPath, processFileFromPath, } from "./cli/index.js";
+//# sourceMappingURL=index.js.map

package/dist/lib/processors/integration/FileProcessorIntegration.d.ts

@@ -0,0 +1,244 @@
+/**
+ * File Processor Integration
+ *
+ * Provides integration between the ProcessorRegistry and message building.
+ * This module allows for automatic file type detection and processing
+ * using the registered file processors.
+ *
+ * @module processors/integration/FileProcessorIntegration
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   processFileWithRegistry,
+ *   processBatchWithRegistry,
+ *   getSupportedFileTypes,
+ *   isFileTypeSupported,
+ *   getProcessorForFile,
+ * } from "./integration/index.js";
+ *
+ * // Process a single file
+ * const { processorName, result } = await processFileWithRegistry(fileInfo);
+ * if (result?.success) {
+ *   console.log(`Processed with ${processorName}:`, result.data);
+ * }
+ *
+ * // Process multiple files
+ * const batchResult = await processBatchWithRegistry(files, { maxFiles: 50 });
+ * console.log(`Successful: ${batchResult.successful.length}`);
+ * console.log(`Failed: ${batchResult.failed.length}`);
+ * console.log(`Skipped: ${batchResult.skipped.length}`);
+ *
+ * // Check if a file type is supported
+ * if (isFileTypeSupported("application/pdf", "document.pdf")) {
+ *   console.log("PDF files are supported");
+ * }
+ * ```
+ */
+import type { FileInfo, FileProcessingResult, ProcessedFileBase, ProcessOptions, ProcessorMatch } from "../base/types.js";
+/**
+ * Options for processing files through the registry.
+ * Extends base ProcessOptions with registry-specific options.
+ *
+ * @example
+ * ```typescript
+ * const options: FileProcessingOptions = {
+ *   // Base options
+ *   authHeaders: { Authorization: "Bearer token" },
+ *   timeout: 60000,
+ *
+ *   // Registry-specific options
+ *   preferredProcessor: "pdf",      // Use specific processor
+ *   allowFallback: true,            // Allow fallback if no processor found
+ *   maxFiles: 50,                   // Limit batch processing
+ * };
+ * ```
+ */
+export interface FileProcessingOptions extends ProcessOptions {
+    /** Preferred processor name (bypasses auto-detection) */
+    preferredProcessor?: string;
+    /** Whether to fall back to default processing if no processor found */
+    allowFallback?: boolean;
+    /** Maximum number of files to process (default: 100) */
+    maxFiles?: number;
+}
+/**
+ * Result of processing multiple files through the registry.
+ * Categorizes files into successful, failed, and skipped.
+ *
+ * @example
+ * ```typescript
+ * const result = await processBatchWithRegistry(files);
+ *
+ * // Handle successful files
+ * for (const { fileInfo, processorName, result } of result.successful) {
+ *   console.log(`${fileInfo.name}: processed by ${processorName}`);
+ * }
+ *
+ * // Handle failed files
+ * for (const { fileInfo, error } of result.failed) {
+ *   console.error(`${fileInfo.name}: ${error}`);
+ * }
+ *
+ * // Handle skipped files
+ * for (const { fileInfo, reason } of result.skipped) {
+ *   console.warn(`${fileInfo.name}: ${reason}`);
+ * }
+ * ```
+ */
+export interface BatchFileProcessingResult {
+    /** Successfully processed files */
+    successful: Array<{
+        fileInfo: FileInfo;
+        processorName: string;
+        result: FileProcessingResult<ProcessedFileBase>;
+    }>;
+    /** Files that failed to process */
+    failed: Array<{
+        fileInfo: FileInfo;
+        error: string;
+    }>;
+    /** Files that were skipped (no processor found or over limit) */
+    skipped: Array<{
+        fileInfo: FileInfo;
+        reason: string;
+    }>;
+}
+/**
+ * Process a single file using the ProcessorRegistry.
+ * Automatically detects the appropriate processor based on MIME type and filename.
+ *
+ * @param fileInfo - File information including content/URL
+ * @param options - Processing options (preferred processor, auth headers, timeout)
+ * @returns Object containing processor name (null if none found) and processing result
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - auto-detect processor
+ * const { processorName, result } = await processFileWithRegistry({
+ *   id: "file-123",
+ *   name: "document.pdf",
+ *   mimetype: "application/pdf",
+ *   size: 1024000,
+ *   url: "https://example.com/document.pdf",
+ * });
+ *
+ * if (result?.success) {
+ *   console.log(`Processed by ${processorName}:`, result.data);
+ * }
+ *
+ * // Use a specific processor
+ * const { result } = await processFileWithRegistry(fileInfo, {
+ *   preferredProcessor: "pdf",
+ * });
+ *
+ * // With authentication and timeout
+ * const { result } = await processFileWithRegistry(fileInfo, {
+ *   authHeaders: { Authorization: "Bearer token123" },
+ *   timeout: 60000,
+ * });
+ * ```
+ */
+export declare function processFileWithRegistry(fileInfo: FileInfo, options?: FileProcessingOptions): Promise<{
+    processorName: string | null;
+    result: FileProcessingResult<ProcessedFileBase> | null;
+}>;
+/**
+ * Process multiple files using the ProcessorRegistry.
+ * Files are processed sequentially and categorized by outcome.
+ *
+ * @param files - Array of file information objects
+ * @param options - Processing options (max files, auth headers, timeout)
+ * @returns Batch result with successful, failed, and skipped files
+ *
+ * @example
+ * ```typescript
+ * const files: FileInfo[] = [
+ *   { id: "1", name: "image.jpg", mimetype: "image/jpeg", size: 512000 },
+ *   { id: "2", name: "doc.pdf", mimetype: "application/pdf", size: 1024000 },
+ *   { id: "3", name: "unknown.xyz", mimetype: "application/octet-stream", size: 100 },
+ * ];
+ *
+ * const result = await processBatchWithRegistry(files, {
+ *   maxFiles: 50,
+ *   timeout: 60000,
+ * });
+ *
+ * console.log(`Processed ${result.successful.length} files successfully`);
+ * console.log(`Failed: ${result.failed.length}`);
+ * console.log(`Skipped: ${result.skipped.length}`);
+ *
+ * // Access individual results
+ * for (const { fileInfo, processorName, result } of result.successful) {
+ *   console.log(`${fileInfo.name}: ${result.data?.size} bytes`);
+ * }
+ * ```
+ */
+export declare function processBatchWithRegistry(files: FileInfo[], options?: FileProcessingOptions): Promise<BatchFileProcessingResult>;
+/**
+ * Get a list of supported file types from the registry.
+ * Returns information about each registered processor including
+ * supported MIME types, extensions, and priority.
+ *
+ * @returns Array of processor information objects
+ *
+ * @example
+ * ```typescript
+ * const supportedTypes = getSupportedFileTypes();
+ *
+ * for (const { name, mimeTypes, extensions, priority } of supportedTypes) {
+ *   console.log(`${name} (priority: ${priority})`);
+ *   console.log(`  MIME types: ${mimeTypes.join(", ")}`);
+ *   console.log(`  Extensions: ${extensions.join(", ")}`);
+ * }
+ * ```
+ */
+export declare function getSupportedFileTypes(): Array<{
+    name: string;
+    mimeTypes: string[];
+    extensions: string[];
+    priority: number;
+}>;
+/**
+ * Check if a file type is supported by any registered processor.
+ *
+ * @param mimetype - MIME type of the file
+ * @param filename - Filename (for extension-based detection)
+ * @returns true if a processor exists for this file type
+ *
+ * @example
+ * ```typescript
+ * // Check by MIME type and filename
+ * if (isFileTypeSupported("application/pdf", "document.pdf")) {
+ *   console.log("PDF files are supported");
+ * }
+ *
+ * // Useful for validation before upload
+ * function validateFile(file: File): boolean {
+ *   return isFileTypeSupported(file.type, file.name);
+ * }
+ * ```
+ */
+export declare function isFileTypeSupported(mimetype: string, filename: string): boolean;
+/**
+ * Get the processor that would handle a specific file.
+ * Returns the full processor match including confidence score.
+ *
+ * @param mimetype - MIME type of the file
+ * @param filename - Filename (for extension-based detection)
+ * @returns Processor match or null if no processor found
+ *
+ * @example
+ * ```typescript
+ * const match = getProcessorForFile("image/jpeg", "photo.jpg");
+ *
+ * if (match) {
+ *   console.log(`Would use ${match.name} processor`);
+ *   console.log(`Priority: ${match.priority}`);
+ *   console.log(`Confidence: ${match.confidence}%`);
+ * } else {
+ *   console.log("No processor available for this file type");
+ * }
+ * ```
+ */
+export declare function getProcessorForFile(mimetype: string, filename: string): ProcessorMatch | null;

package/dist/lib/processors/integration/FileProcessorIntegration.js

@@ -0,0 +1,273 @@
+/**
+ * File Processor Integration
+ *
+ * Provides integration between the ProcessorRegistry and message building.
+ * This module allows for automatic file type detection and processing
+ * using the registered file processors.
+ *
+ * @module processors/integration/FileProcessorIntegration
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   processFileWithRegistry,
+ *   processBatchWithRegistry,
+ *   getSupportedFileTypes,
+ *   isFileTypeSupported,
+ *   getProcessorForFile,
+ * } from "./integration/index.js";
+ *
+ * // Process a single file
+ * const { processorName, result } = await processFileWithRegistry(fileInfo);
+ * if (result?.success) {
+ *   console.log(`Processed with ${processorName}:`, result.data);
+ * }
+ *
+ * // Process multiple files
+ * const batchResult = await processBatchWithRegistry(files, { maxFiles: 50 });
+ * console.log(`Successful: ${batchResult.successful.length}`);
+ * console.log(`Failed: ${batchResult.failed.length}`);
+ * console.log(`Skipped: ${batchResult.skipped.length}`);
+ *
+ * // Check if a file type is supported
+ * if (isFileTypeSupported("application/pdf", "document.pdf")) {
+ *   console.log("PDF files are supported");
+ * }
+ * ```
+ */
+import { withTimeout } from "../../utils/errorHandling.js";
+import { getProcessorRegistry } from "../registry/index.js";
+// =============================================================================
+// SINGLE FILE PROCESSING
+// =============================================================================
+/**
+ * Process a single file using the ProcessorRegistry.
+ * Automatically detects the appropriate processor based on MIME type and filename.
+ *
+ * @param fileInfo - File information including content/URL
+ * @param options - Processing options (preferred processor, auth headers, timeout)
+ * @returns Object containing processor name (null if none found) and processing result
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - auto-detect processor
+ * const { processorName, result } = await processFileWithRegistry({
+ *   id: "file-123",
+ *   name: "document.pdf",
+ *   mimetype: "application/pdf",
+ *   size: 1024000,
+ *   url: "https://example.com/document.pdf",
+ * });
+ *
+ * if (result?.success) {
+ *   console.log(`Processed by ${processorName}:`, result.data);
+ * }
+ *
+ * // Use a specific processor
+ * const { result } = await processFileWithRegistry(fileInfo, {
+ *   preferredProcessor: "pdf",
+ * });
+ *
+ * // With authentication and timeout
+ * const { result } = await processFileWithRegistry(fileInfo, {
+ *   authHeaders: { Authorization: "Bearer token123" },
+ *   timeout: 60000,
+ * });
+ * ```
+ */
+export async function processFileWithRegistry(fileInfo, options) {
+    const registry = getProcessorRegistry();
+    const timeout = options?.timeout ?? 30000;
+    // Use preferred processor if specified
+    if (options?.preferredProcessor) {
+        const processor = registry.getProcessor(options.preferredProcessor);
+        if (processor) {
+            const result = await withTimeout(processor.processor.processFile(fileInfo, options), timeout, new Error(`File processing timed out after ${timeout}ms`));
+            return { processorName: options.preferredProcessor, result };
+        }
+    }
+    // Auto-detect processor based on MIME type and filename
+    const match = registry.findProcessor(fileInfo.mimetype, fileInfo.name);
+    if (!match) {
+        return { processorName: null, result: null };
+    }
+    const processor = match.processor;
+    const result = await withTimeout(processor.processFile(fileInfo, options), timeout, new Error(`File processing timed out after ${timeout}ms`));
+    return { processorName: match.name, result };
+}
+// =============================================================================
+// BATCH FILE PROCESSING
+// =============================================================================
+/**
+ * Process multiple files using the ProcessorRegistry.
+ * Files are processed sequentially and categorized by outcome.
+ *
+ * @param files - Array of file information objects
+ * @param options - Processing options (max files, auth headers, timeout)
+ * @returns Batch result with successful, failed, and skipped files
+ *
+ * @example
+ * ```typescript
+ * const files: FileInfo[] = [
+ *   { id: "1", name: "image.jpg", mimetype: "image/jpeg", size: 512000 },
+ *   { id: "2", name: "doc.pdf", mimetype: "application/pdf", size: 1024000 },
+ *   { id: "3", name: "unknown.xyz", mimetype: "application/octet-stream", size: 100 },
+ * ];
+ *
+ * const result = await processBatchWithRegistry(files, {
+ *   maxFiles: 50,
+ *   timeout: 60000,
+ * });
+ *
+ * console.log(`Processed ${result.successful.length} files successfully`);
+ * console.log(`Failed: ${result.failed.length}`);
+ * console.log(`Skipped: ${result.skipped.length}`);
+ *
+ * // Access individual results
+ * for (const { fileInfo, processorName, result } of result.successful) {
+ *   console.log(`${fileInfo.name}: ${result.data?.size} bytes`);
+ * }
+ * ```
+ */
+export async function processBatchWithRegistry(files, options) {
+    const result = {
+        successful: [],
+        failed: [],
+        skipped: [],
+    };
+    const maxFiles = options?.maxFiles ?? 100;
+    const filesToProcess = files.slice(0, maxFiles);
+    // Process files sequentially
+    for (const fileInfo of filesToProcess) {
+        try {
+            const { processorName, result: processResult } = await processFileWithRegistry(fileInfo, options);
+            if (!processorName || !processResult) {
+                // No processor found for this file type
+                if (!options?.allowFallback) {
+                    result.skipped.push({
+                        fileInfo,
+                        reason: `No processor found for MIME type: ${fileInfo.mimetype}`,
+                    });
+                }
+                else {
+                    // allowFallback is true but no fallback processor implemented yet
+                    result.skipped.push({
+                        fileInfo,
+                        reason: `No processor found for MIME type: ${fileInfo.mimetype} (fallback not yet implemented)`,
+                    });
+                }
+                continue;
+            }
+            if (processResult.success) {
+                result.successful.push({
+                    fileInfo,
+                    processorName,
+                    result: processResult,
+                });
+            }
+            else {
+                result.failed.push({
+                    fileInfo,
+                    error: processResult.error?.message || "Unknown error",
+                });
+            }
+        }
+        catch (error) {
+            result.failed.push({
+                fileInfo,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    // Track skipped files that exceeded the limit
+    if (files.length > maxFiles) {
+        for (let i = maxFiles; i < files.length; i++) {
+            result.skipped.push({
+                fileInfo: files[i],
+                reason: `Exceeded maximum file limit (${maxFiles})`,
+            });
+        }
+    }
+    return result;
+}
+// =============================================================================
+// PROCESSOR DISCOVERY
+// =============================================================================
+/**
+ * Get a list of supported file types from the registry.
+ * Returns information about each registered processor including
+ * supported MIME types, extensions, and priority.
+ *
+ * @returns Array of processor information objects
+ *
+ * @example
+ * ```typescript
+ * const supportedTypes = getSupportedFileTypes();
+ *
+ * for (const { name, mimeTypes, extensions, priority } of supportedTypes) {
+ *   console.log(`${name} (priority: ${priority})`);
+ *   console.log(`  MIME types: ${mimeTypes.join(", ")}`);
+ *   console.log(`  Extensions: ${extensions.join(", ")}`);
+ * }
+ * ```
+ */
+export function getSupportedFileTypes() {
+    const registry = getProcessorRegistry();
+    const processors = registry.listProcessors();
+    return processors.map((p) => ({
+        name: p.name,
+        mimeTypes: p.processor.getConfig().supportedMimeTypes || [],
+        extensions: p.processor.getConfig().supportedExtensions || [],
+        priority: p.priority,
+    }));
+}
+/**
+ * Check if a file type is supported by any registered processor.
+ *
+ * @param mimetype - MIME type of the file
+ * @param filename - Filename (for extension-based detection)
+ * @returns true if a processor exists for this file type
+ *
+ * @example
+ * ```typescript
+ * // Check by MIME type and filename
+ * if (isFileTypeSupported("application/pdf", "document.pdf")) {
+ *   console.log("PDF files are supported");
+ * }
+ *
+ * // Useful for validation before upload
+ * function validateFile(file: File): boolean {
+ *   return isFileTypeSupported(file.type, file.name);
+ * }
+ * ```
+ */
+export function isFileTypeSupported(mimetype, filename) {
+    const registry = getProcessorRegistry();
+    return registry.findProcessor(mimetype, filename) !== null;
+}
+/**
+ * Get the processor that would handle a specific file.
+ * Returns the full processor match including confidence score.
+ *
+ * @param mimetype - MIME type of the file
+ * @param filename - Filename (for extension-based detection)
+ * @returns Processor match or null if no processor found
+ *
+ * @example
+ * ```typescript
+ * const match = getProcessorForFile("image/jpeg", "photo.jpg");
+ *
+ * if (match) {
+ *   console.log(`Would use ${match.name} processor`);
+ *   console.log(`Priority: ${match.priority}`);
+ *   console.log(`Confidence: ${match.confidence}%`);
+ * } else {
+ *   console.log("No processor available for this file type");
+ * }
+ * ```
+ */
+export function getProcessorForFile(mimetype, filename) {
+    const registry = getProcessorRegistry();
+    return registry.findProcessor(mimetype, filename);
+}
+//# sourceMappingURL=FileProcessorIntegration.js.map

package/dist/lib/processors/integration/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * File Processor Integration Module
+ *
+ * Provides integration between the ProcessorRegistry and message building.
+ * Exports utilities for processing files through registered processors
+ * with automatic type detection and batch processing support.
+ *
+ * @module processors/integration
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   // Single file processing
+ *   processFileWithRegistry,
+ *
+ *   // Batch processing
+ *   processBatchWithRegistry,
+ *
+ *   // Discovery utilities
+ *   getSupportedFileTypes,
+ *   isFileTypeSupported,
+ *   getProcessorForFile,
+ *
+ *   // Types
+ *   type FileProcessingOptions,
+ *   type BatchFileProcessingResult,
+ * } from "./integration/index.js";
+ *
+ * // Process a single file with auto-detection
+ * const { processorName, result } = await processFileWithRegistry(fileInfo);
+ *
+ * // Process multiple files
+ * const batchResult = await processBatchWithRegistry(files, { maxFiles: 50 });
+ *
+ * // Check supported types
+ * const supported = getSupportedFileTypes();
+ * const isSupported = isFileTypeSupported("application/pdf", "doc.pdf");
+ * const match = getProcessorForFile("image/jpeg", "photo.jpg");
+ * ```
+ */
+export { getProcessorForFile, getSupportedFileTypes, isFileTypeSupported, processBatchWithRegistry, processFileWithRegistry, } from "./FileProcessorIntegration.js";
+export type { BatchFileProcessingResult, FileProcessingOptions, } from "./FileProcessorIntegration.js";